wowok 2.1.10 → 2.1.13

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

@@ -1,363 +1,333 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 });
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var base_exports = {};
-__export(base_exports, {
-  CallBase: () => CallBase,
-  ResponseData: () => ResponseData,
-  getCoinParam: () => getCoinParam,
-  isCallResultSubmission: () => isCallResultSubmission
-});
-module.exports = __toCommonJS(base_exports);
-var import_client = require("../../client/index.js");
-var import_transactions = require("../../transactions/index.js");
-var import_sui_types = require("../../utils/sui-types.js");
-var import_common = require("../common.js");
-var import_exception = require("../exception.js");
-var import_lodash = __toESM(require("lodash"));
-var import_account = require("../local/account.js");
-var import_local = require("../local/local.js");
-var import_object = require("../query/object.js");
-var import_passport = require("./passport.js");
-var import_resource = require("./resource.js");
-var import_entity = require("./entity.js");
-var import_util = require("./util.js");
-var import_config = require("../local/config.js");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallBase = void 0;
+exports.isCallResultSubmission = isCallResultSubmission;
+exports.ResponseData = ResponseData;
+exports.getCoinParam = getCoinParam;
+const index_js_1 = require("../../client/index.js");
+const index_js_2 = require("../../transactions/index.js");
+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 lodash_1 = __importDefault(require("lodash"));
+const account_js_1 = require("../local/account.js");
+const local_js_1 = require("../local/local.js");
+const object_js_1 = require("../query/object.js");
+const passport_js_1 = require("./passport.js");
+const resource_js_1 = require("./resource.js");
+const entity_js_1 = require("./entity.js");
+const util_js_1 = require("./util.js");
+const config_js_1 = require("../local/config.js");
 function isCallResultSubmission(result) {
-  return result?.submission && result?.submission?.length > 0;
+    return (result?.submission && result?.submission?.length > 0);
 }
 function ResponseData(response) {
-  if (response?.digest) {
-    const res = [];
-    response?.objectChanges?.forEach(
-      (v) => {
-        const type_raw = v?.objectType;
-        const type = (0, import_object.raw2type)(type_raw);
-        if (type) {
-          res.push({
-            type,
-            type_raw,
-            object: v?.objectId,
-            version: v?.version,
-            owner: v?.owner,
-            change: v.type
-          });
-        }
-      }
-    );
-    return res;
-  }
-  return [];
+    //console.dir(response, { depth: null, colors: true });
+    if (response?.digest) {
+        const res = [];
+        response?.objectChanges?.forEach((v) => {
+            const type_raw = v?.objectType;
+            const type = (0, object_js_1.raw2type)(type_raw);
+            if (type) {
+                res.push({
+                    type: type,
+                    type_raw: type_raw,
+                    object: v?.objectId,
+                    version: v?.version,
+                    owner: v?.owner,
+                    change: v.type,
+                });
+            }
+        });
+        return res;
+    }
+    return [];
 }
 class CallBase {
-  constructor() {
     // operation implementation for a call
-    __publicField(this, "newResource");
-    __publicField(this, "traceMarkNew", /* @__PURE__ */ new Map());
-    __publicField(this, "content");
-    __publicField(this, "env_ready", false);
-  }
-  async operate(_env, _tx, _passport, _submission) {
-  }
-  async prepare(env) {
-    await this.env_prepare(env);
-  }
-  // return WitnessFill to resolve filling witness, and than 'call_with_witness' to complete the call;
-  // return ResponseData when the call has completed;
-  // throw an exception when errors.
-  async call(_env) {
-    return void 0;
-  }
-  async env_prepare(env) {
-    if (this.env_ready) {
-      return;
+    newResource;
+    traceMarkNew = new Map();
+    content = undefined;
+    env_ready = false;
+    async operate(_env, _tx, _passport, _submission) { }
+    async prepare(env) {
+        await this.env_prepare(env);
     }
-    await (0, import_util.resolveCallEnv)(env);
-    this.env_ready = true;
-  }
-  async call_with_submission(env, info, freezePassport) {
-    if (info.guard.length > 0) {
-      await this.prepare(env);
-      await this.check_passport(env, info, freezePassport);
+    // return WitnessFill to resolve filling witness, and than 'call_with_witness' to complete the call;
+    // return ResponseData when the call has completed;
+    // throw an exception when errors.
+    async call(_env) {
+        return undefined;
     }
-    return void 0;
-  }
-  async check_guard_and_call(env, guards_needed) {
-    env.permission_guard?.forEach((guard) => {
-      if (!(0, import_sui_types.isValidWowAddress)(guard)) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.IsValidAddress,
-          `env permission_guard: ${guard}`
-        );
-      }
-      guards_needed.push(guard);
-    });
-    if (guards_needed.length > 0) {
-      const param = await (0, import_passport.get_guardSubmissions)(env, guards_needed);
-      if (param.submission.length > 0) {
-        return {
-          type: "submission",
-          guard: param.guard,
-          submission: param.submission
-        };
-      }
-      return await this.check_passport(env, param);
-    } else {
-      return await this.exec(env);
+    async env_prepare(env) {
+        if (this.env_ready) {
+            return;
+        }
+        await (0, util_js_1.resolveCallEnv)(env);
+        this.env_ready = true;
     }
-  }
-  async check_permission_and_call(env, permission, permIndex, guards_needed, checkOwner, checkAdmin) {
-    let bAdmin = false;
-    const p = await (0, import_object.query_objects)({
-      objects: [permission],
-      no_cache: env.no_cache,
-      network: env.network
-    });
-    if (!p.objects?.[0] || p.objects?.[0].type !== "Permission") {
-      (0, import_exception.W_ERROR)(import_exception.WErrors.NoPermission, "permission object not found");
+    async call_with_submission(env, info, freezePassport) {
+        if (info.guard.length > 0) {
+            await this.prepare(env); // NOTE: prepare some
+            await this.check_passport(env, info, freezePassport);
+        }
+        return undefined;
     }
-    const perm_object = p.objects?.[0];
-    const acc = await (0, import_util.getCallEnvAccount)(env);
-    bAdmin = perm_object.admin.includes(acc);
-    if (checkOwner && perm_object.builder !== acc)
-      (0, import_exception.W_ERROR)(import_exception.WErrors.NoPermission, `${acc} owner permission required`);
-    if (checkAdmin && !bAdmin)
-      (0, import_exception.W_ERROR)(import_exception.WErrors.NoPermission, `${acc} admin permission required`);
-    env.permission_guard?.forEach((guard) => {
-      if (!(0, import_sui_types.isValidWowAddress)(guard)) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.IsValidAddress,
-          `env permission_guard ${guard}`
-        );
-      }
-      guards_needed.push(guard);
-    });
-    if (permIndex.length > 0 && !bAdmin) {
-      const addressesToCheck = [acc, ...env.permission_guard ?? []];
-      const permissionPromises = addressesToCheck.map(async (address) => {
-        const p2 = await (0, import_object.queryTableItem_PermissionPerm)({
-          parent: permission,
-          address,
-          no_cache: env.no_cache,
-          network: env.network
+    async check_guard_and_call(env, guards_needed) {
+        env.permission_guard?.forEach((guard) => {
+            if (!(0, sui_types_js_1.isValidWowAddress)(guard)) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidAddress, `env permission_guard: ${guard}`);
+            }
+            guards_needed.push(guard);
         });
-        if (p2 && p2.type === "TableItem_PermissionPerm") {
-          const perm = p2;
-          return { address, permissions: perm.perm };
+        // check submissions
+        if (guards_needed.length > 0) {
+            const param = await (0, passport_js_1.get_guardSubmissions)(env, guards_needed);
+            if (param.submission.length > 0) {
+                return {
+                    type: "submission",
+                    guard: param.guard,
+                    submission: param.submission,
+                };
+            }
+            // check passport
+            return await this.check_passport(env, param);
+        }
+        else {
+            return await this.exec(env);
         }
-        return { address, permissions: [] };
-      });
-      const permissionResults = await Promise.all(permissionPromises);
-      const allAvailablePermissions = /* @__PURE__ */ new Set();
-      permissionResults.forEach((result) => {
-        result.permissions.forEach(
-          (perm) => allAvailablePermissions.add(perm)
-        );
-      });
-      const missingPermissions = permIndex.filter(
-        (perm) => !allAvailablePermissions.has(perm)
-      );
-      if (missingPermissions.length > 0) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.NoPermission,
-          `Missing permissions ${missingPermissions.join(", ")} in ${permission}`
-        );
-      }
-    }
-    if (guards_needed.length > 0) {
-      const param = await (0, import_passport.get_guardSubmissions)(env, guards_needed);
-      if (param.submission.length > 0) {
-        return {
-          type: "submission",
-          guard: param.guard,
-          submission: param.submission
-        };
-      }
-      return await this.check_passport(env, param);
-    } else {
-      return await this.exec(env);
-    }
-  }
-  async check_passport(env, param, freezePassport) {
-    const tx = new import_transactions.Transaction();
-    const passport = (0, import_passport.newPassport)(tx);
-    for (const v of param.guard) {
-      await (0, import_passport.guardAdd)(
-        tx,
-        passport,
-        v.object,
-        param.submission.find((i) => i.guard === v.object)?.submission ?? [],
-        v.impack
-      );
-    }
-    (0, import_passport.verify)(tx, passport);
-    await this.operate(env, tx, passport, param.submission);
-    if (freezePassport) {
-      (0, import_passport.freeze)(tx, passport);
-    } else {
-      (0, import_passport.destroy)(tx, passport);
-    }
-    return await this.sign_and_commit(env, tx);
-  }
-  async exec(env) {
-    const tx = new import_transactions.Transaction();
-    await this.operate(env, tx);
-    return await this.sign_and_commit(env, tx);
-  }
-  async new_with_mark(env, tx, type, object, named_new, innerTags = [import_resource.TagName.Launch]) {
-    const tags = named_new?.tags ? import_lodash.default.uniq([...named_new.tags, ...innerTags]) : import_lodash.default.uniq([...innerTags]);
-    if (named_new) {
-      named_new.tags = tags;
-      this.traceMarkNew.set(type, named_new);
     }
-    if (!named_new?.onChain) return;
-    if (!this.newResource) {
-      let r;
-      try {
-        r = await (0, import_object.queryTableItem_EntityRegistrar)({
-          address: await (0, import_util.getCallEnvAccount)(env),
-          no_cache: env.no_cache,
-          network: env.network
+    async check_permission_and_call(env, permission, permIndex, guards_needed, checkOwner, checkAdmin) {
+        let bAdmin = false;
+        const p = await (0, object_js_1.query_objects)({
+            objects: [permission],
+            no_cache: env.no_cache,
+            network: env.network,
         });
-      } catch (e) {
-      }
-      if (r && r.type !== "TableItem_EntityRegistrar") {
-        (0, import_exception.W_ERROR)(import_exception.WErrors.NoPermission, "no entity registrar found");
-      }
-      if (r?.mark_object) {
-        (0, import_resource.addObjectTags)(tx, r.mark_object, {
-          address: object,
-          tags
+        if (!p.objects?.[0] || p.objects?.[0].type !== "Permission") {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.NoPermission, "permission object not found");
+        }
+        const perm_object = p.objects?.[0];
+        const acc = await (0, util_js_1.getCallEnvAccount)(env);
+        bAdmin = perm_object.admin.includes(acc);
+        //@ notice: builder
+        if (checkOwner && perm_object.builder !== acc)
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.NoPermission, `${acc} owner permission required`);
+        if (checkAdmin && !bAdmin)
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.NoPermission, `${acc} admin permission required`);
+        env.permission_guard?.forEach((guard) => {
+            if (!(0, sui_types_js_1.isValidWowAddress)(guard)) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidAddress, `env permission_guard ${guard}`);
+            }
+            guards_needed.push(guard);
         });
-        return;
-      } else {
-        this.newResource = (0, import_entity.register_with_resource_forced)(
-          tx,
-          typeof env.referrer === "string" ? env.referrer : null
-          //@ referrer
-        );
-      }
-    }
-    if (this.newResource) {
-      (0, import_resource.addObjectTags)(tx, this.newResource, {
-        address: object,
-        tags
-      });
+        if (permIndex.length > 0 && !bAdmin) {
+            // Check both env.guard (if exists) and env.account
+            const addressesToCheck = [acc, ...(env.permission_guard ?? [])];
+            // Use Promise.all to query permissions in parallel
+            const permissionPromises = addressesToCheck.map(async (address) => {
+                const p = await (0, object_js_1.queryTableItem_PermissionPerm)({
+                    parent: permission,
+                    address: address,
+                    no_cache: env.no_cache,
+                    network: env.network,
+                });
+                if (p && p.type === "TableItem_PermissionPerm") {
+                    const perm = p;
+                    /*console.log(
+                        `PermissionPerm: ${address} -> ${perm.perm.join(", ")}`,
+                    );*/
+                    return { address, permissions: perm.perm };
+                }
+                return { address, permissions: [] };
+            });
+            const permissionResults = await Promise.all(permissionPromises);
+            // Collect all available permissions from all addresses
+            const allAvailablePermissions = new Set();
+            permissionResults.forEach((result) => {
+                result.permissions.forEach((perm) => allAvailablePermissions.add(perm));
+            });
+            // Check if all required permissions are available from any address
+            const missingPermissions = permIndex.filter((perm) => !allAvailablePermissions.has(perm));
+            if (missingPermissions.length > 0) {
+                // If we reach here, some permissions are missing from all addresses
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.NoPermission, `Missing permissions ${missingPermissions.join(", ")} in ${permission}`);
+            }
+        }
+        // check submissions
+        //console.log(`guards_needed: ${guards_needed.join(", ")}`);
+        if (guards_needed.length > 0) {
+            const param = await (0, passport_js_1.get_guardSubmissions)(env, guards_needed);
+            //console.dir(param, { depth: null, colors: true });
+            if (param.submission.length > 0) {
+                return {
+                    type: "submission",
+                    guard: param.guard,
+                    submission: param.submission,
+                };
+            }
+            // check passport
+            return await this.check_passport(env, param);
+        }
+        else {
+            return await this.exec(env);
+        }
     }
-  }
-  async update_content(env, type, object) {
-    if (this.content || !object) return;
-    const r = await (0, import_object.query_objects)({
-      objects: [object],
-      no_cache: env.no_cache,
-      network: env.network
-    });
-    if (!r.objects || r?.objects?.length !== 1 || r?.objects[0]?.type !== type) {
-      (0, import_exception.W_ERROR)(import_exception.WErrors.Fail, `Fetch ${type} object ${object} failed`);
+    async check_passport(env, param, freezePassport) {
+        //console.dir(param, { depth: null, colors: true });
+        const tx = new index_js_2.Transaction();
+        const passport = (0, passport_js_1.newPassport)(tx);
+        for (const v of param.guard) {
+            await (0, passport_js_1.guardAdd)(tx, passport, v.object, param.submission.find((i) => i.guard === v.object)
+                ?.submission ?? [], v.impack);
+        }
+        (0, passport_js_1.verify)(tx, passport);
+        await this.operate(env, tx, passport, param.submission);
+        if (freezePassport) {
+            (0, passport_js_1.freeze)(tx, passport);
+        }
+        else {
+            (0, passport_js_1.destroy)(tx, passport);
+        }
+        return await this.sign_and_commit(env, tx);
     }
-    this.content = r?.objects[0];
-  }
-  async sign_and_commit(env, tx) {
-    if (this.newResource) {
-      (0, import_resource.create)(tx, this.newResource);
-      this.newResource = void 0;
+    async exec(env) {
+        const tx = new index_js_2.Transaction();
+        await this.operate(env, tx);
+        return await this.sign_and_commit(env, tx);
     }
-    let r = await import_account.Account.Instance().sign_and_commit(
-      tx,
-      await (0, import_util.getCallEnvAccount)(env),
-      env.network
-    );
-    if (!r) {
-      (0, import_exception.W_ERROR)(import_exception.WErrors.Fail, "sign and commit failed");
+    async new_with_mark(env, tx, type, object, named_new, innerTags = [resource_js_1.TagName.Launch]) {
+        const tags = named_new?.tags
+            ? lodash_1.default.uniq([...named_new.tags, ...innerTags])
+            : lodash_1.default.uniq([...innerTags]);
+        if (named_new) {
+            named_new.tags = tags;
+            this.traceMarkNew.set(type, named_new);
+        }
+        if (!named_new?.onChain)
+            return;
+        // onchain mark
+        if (!this.newResource) {
+            let r;
+            try {
+                r = await (0, object_js_1.queryTableItem_EntityRegistrar)({
+                    address: await (0, util_js_1.getCallEnvAccount)(env),
+                    no_cache: env.no_cache,
+                    network: env.network,
+                });
+            }
+            catch (e) {
+                // "error":{"code":"dynamicFieldNotFound",
+                //console.log(`queryTableItem_Entity failed: ${e}`);
+            }
+            if (r && r.type !== "TableItem_EntityRegistrar") {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.NoPermission, "no entity registrar found");
+            }
+            // DONT change this.newResource
+            if (r?.mark_object) {
+                (0, resource_js_1.addObjectTags)(tx, r.mark_object, {
+                    address: object,
+                    tags,
+                });
+                return; // return
+            }
+            else {
+                // 前面的逻辑已转换为string，故只用判断是否为string
+                this.newResource = (0, entity_js_1.register_with_resource_forced)(tx, typeof env.referrer === "string" ? env.referrer : null);
+            }
+        }
+        if (this.newResource) {
+            (0, resource_js_1.addObjectTags)(tx, this.newResource, {
+                address: object,
+                tags,
+            });
+        }
     }
-    if (r?.digest && !r?.objectChanges) {
-      const client = new import_client.SuiClient({
-        url: (0, import_client.getFullnodeUrl)(
-          await import_config.Config.Instance().network_get(env.network)
-        )
-      });
-      r = await client.getTransactionBlock({
-        digest: r?.digest,
-        options: { showObjectChanges: true }
-      });
+    async update_content(env, type, object) {
+        if (this.content || !object)
+            return;
+        const r = await (0, object_js_1.query_objects)({
+            objects: [object],
+            no_cache: env.no_cache,
+            network: env.network,
+        });
+        if (!r.objects ||
+            r?.objects?.length !== 1 ||
+            r?.objects[0]?.type !== type) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.Fail, `Fetch ${type} object ${object} failed`);
+        }
+        this.content = r?.objects[0];
     }
-    const res = ResponseData(r);
-    for (let i = 0; i < res.length; ++i) {
-      const v = res[i];
-      if (v.type && v.change === "created") {
-        const namedNew = this.traceMarkNew.get(v.type);
-        if (namedNew) {
-          await import_local.LocalMark.Instance().put([
-            {
-              name: namedNew.name ? {
-                value: namedNew.name,
-                replaceExistName: namedNew.replaceExistName
-              } : void 0,
-              address: v.object,
-              tags: namedNew?.tags ? [...namedNew.tags, v.type] : [v.type]
+    async sign_and_commit(env, tx) {
+        if (this.newResource) {
+            (0, resource_js_1.create)(tx, this.newResource); //@ resource launch, if created.
+            this.newResource = undefined;
+        }
+        let r = await account_js_1.Account.Instance().sign_and_commit(tx, await (0, util_js_1.getCallEnvAccount)(env), env.network);
+        if (!r) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.Fail, "sign and commit failed");
+        }
+        if (r?.digest && !r?.objectChanges) {
+            const client = new index_js_1.SuiClient({
+                url: (0, index_js_1.getFullnodeUrl)(await config_js_1.Config.Instance().network_get(env.network)),
+            });
+            r = await client.getTransactionBlock({
+                digest: r?.digest,
+                options: { showObjectChanges: true },
+            });
+        }
+        // save the mark locally, anyway
+        const res = ResponseData(r);
+        for (let i = 0; i < res.length; ++i) {
+            const v = res[i];
+            if (v.type && v.change === "created") {
+                const namedNew = this.traceMarkNew.get(v.type);
+                if (namedNew) {
+                    await local_js_1.LocalMark.Instance().put([
+                        {
+                            name: namedNew.name
+                                ? {
+                                    value: namedNew.name,
+                                    replaceExistName: namedNew.replaceExistName,
+                                }
+                                : undefined,
+                            address: v.object,
+                            tags: namedNew?.tags
+                                ? [...namedNew.tags, v.type]
+                                : [v.type],
+                        },
+                    ]);
+                }
             }
-          ]);
         }
-      }
+        return r;
     }
-    return r;
-  }
 }
+exports.CallBase = CallBase;
 async function getCoinParam(env, tx, coin, coinType) {
-  let coinParam;
-  if ("balance" in coin && coin.balance != null) {
-    if (!(0, import_common.isValidU64)(coin.balance)) {
-      (0, import_exception.W_ERROR)(
-        import_exception.WErrors.IsValidU64,
-        `Total pay balance ${coin.balance} is not valid`
-      );
+    let coinParam;
+    if ("balance" in coin && coin.balance != null) {
+        if (!(0, common_js_1.isValidU64)(coin.balance)) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidU64, `Total pay balance ${coin.balance} is not valid`);
+        }
+        coinParam = await account_js_1.Account.Instance().get_coin_object(tx, coin.balance, coinType, await (0, util_js_1.getCallEnvAccount)(env), env.network);
+    }
+    else if ("coin" in coin && coin.coin != null) {
+        if (typeof coin.coin === "string") {
+            coinParam = await local_js_1.LocalMark.Instance().get_address(coin.coin);
+        }
+        else {
+            coinParam = coin.coin;
+        }
     }
-    coinParam = await import_account.Account.Instance().get_coin_object(
-      tx,
-      coin.balance,
-      coinType,
-      await (0, import_util.getCallEnvAccount)(env),
-      env.network
-    );
-  } else if ("coin" in coin && coin.coin != null) {
-    if (typeof coin.coin === "string") {
-      coinParam = await import_local.LocalMark.Instance().get_address(coin.coin);
-    } else {
-      coinParam = coin.coin;
+    if (!coinParam) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Total pay ${JSON.stringify(coin)} is allocated failed`);
     }
-  }
-  if (!coinParam) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Total pay ${JSON.stringify(coin)} is allocated failed`
-    );
-  }
-  return (0, import_common.toTxObject)(tx, coinParam);
+    return (0, common_js_1.toTxObject)(tx, coinParam);
 }
+//# sourceMappingURL=base.js.map