wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,1375 @@
+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,
+  toTxU16,
+  toTxAddress,
+  toTxAddressVec,
+  toTxU16Vec,
+  MAX_DESCRIPTION_LENGTH,
+  isValidLongName,
+  MAX_LONG_NAME_LENGTH,
+  GetObject,
+  GetObjectExisted,
+  PackageAddress,
+  serviceFn,
+  IsValidArgType,
+  contactFn
+} from "../common.js";
+import { W_ERROR, WErrors } from "../exception.js";
+import { isValidDescription, toTxString } from "../common.js";
+import { CallBase } from "./base.js";
+import { ObjectType, query_objects } from "../query/object.js";
+import {
+  GetAccountOrMark_Address,
+  GetManyAccountOrMark_Address,
+  LocalMark
+} from "../local/index.js";
+import { parseObjectType, permission_set } from "../util.js";
+import {
+  demandFn,
+  machineFn,
+  treasuryFn,
+  arbitrationFn,
+  repositoryFn,
+  rewardFn
+} from "../common.js";
+import { query_received } from "../query/received.js";
+var BuiltinPermissionIndex = /* @__PURE__ */ ((BuiltinPermissionIndex2) => {
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["REPOSITORY_NEW"] = 100] = "REPOSITORY_NEW";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["REPOSITORY_DESCRIPTION"] = 101] = "REPOSITORY_DESCRIPTION";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["REPOSITORY_POLICY"] = 102] = "REPOSITORY_POLICY";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["REPOSITORY_REWARD"] = 103] = "REPOSITORY_REWARD";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["REPOSITORY_OWNER_RECEIVE"] = 104] = "REPOSITORY_OWNER_RECEIVE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["REPOSITORY_UM"] = 105] = "REPOSITORY_UM";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["REWARD_NEW"] = 150] = "REWARD_NEW";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["REWARD_DESCRIPTION"] = 151] = "REWARD_DESCRIPTION";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["REWARD_GUARD"] = 152] = "REWARD_GUARD";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["REWARD_COIN_ADD"] = 153] = "REWARD_COIN_ADD";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["REWARD_RECEIVE"] = 154] = "REWARD_RECEIVE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["REWARD_GUARD_EXPIRATION_TIME_ADD"] = 155] = "REWARD_GUARD_EXPIRATION_TIME_ADD";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["REWARD_OWNER_RECEIVE"] = 156] = "REWARD_OWNER_RECEIVE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["REWARD_UM"] = 157] = "REWARD_UM";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["MACHINE_NEW"] = 200] = "MACHINE_NEW";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["MACHINE_DESCRIPTION"] = 201] = "MACHINE_DESCRIPTION";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["MACHINE_CONSENSUS_REPOSITORIES"] = 203] = "MACHINE_CONSENSUS_REPOSITORIES";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["MACHINE_PAUSE"] = 204] = "MACHINE_PAUSE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["MACHINE_PUBLISH"] = 205] = "MACHINE_PUBLISH";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["MACHINE_NODE"] = 206] = "MACHINE_NODE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["MACHINE_OWNER_RECEIVE"] = 207] = "MACHINE_OWNER_RECEIVE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["MACHINE_UM"] = 208] = "MACHINE_UM";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["PROGRESS_NEW"] = 220] = "PROGRESS_NEW";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["PROGRESS_NAMED_OPERATOR"] = 221] = "PROGRESS_NAMED_OPERATOR";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["PROGRESS_TASK"] = 222] = "PROGRESS_TASK";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["PROGRESS_CONTEXT_REPOSITORY"] = 223] = "PROGRESS_CONTEXT_REPOSITORY";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["PROGRESS_UNHOLD"] = 224] = "PROGRESS_UNHOLD";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["PROGRESS_OWNER_RECEIVE"] = 225] = "PROGRESS_OWNER_RECEIVE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["TREASURY_NEW"] = 250] = "TREASURY_NEW";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["TREASURY_DESCRIPTION"] = 251] = "TREASURY_DESCRIPTION";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["TREASURY_DEPOSIT"] = 252] = "TREASURY_DEPOSIT";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["TREASURY_RECEIVE"] = 253] = "TREASURY_RECEIVE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["TREASURY_WITHDRAW"] = 254] = "TREASURY_WITHDRAW";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["TREASURY_EXTERNAL_DEPOSIT"] = 255] = "TREASURY_EXTERNAL_DEPOSIT";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["TREASURY_EXTERNAL_WITHDRAW"] = 256] = "TREASURY_EXTERNAL_WITHDRAW";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["TREASURY_EXTERNAL_DEPOSIT_GUARD"] = 257] = "TREASURY_EXTERNAL_DEPOSIT_GUARD";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["TREASURY_EXTERNAL_WITHDRAW_GUARD"] = 258] = "TREASURY_EXTERNAL_WITHDRAW_GUARD";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["TREASURY_OWNER_RECEIVE"] = 259] = "TREASURY_OWNER_RECEIVE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["TREASURY_UM"] = 260] = "TREASURY_UM";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_NEW"] = 300] = "SERVICE_NEW";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_DESCRIPTION"] = 301] = "SERVICE_DESCRIPTION";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_LOCATION"] = 303] = "SERVICE_LOCATION";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_REPOSITORY"] = 304] = "SERVICE_REPOSITORY";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_SALES"] = 305] = "SERVICE_SALES";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_MACHINE"] = 306] = "SERVICE_MACHINE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_BUY_GUARD"] = 307] = "SERVICE_BUY_GUARD";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_ARBITRATION"] = 308] = "SERVICE_ARBITRATION";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_CUSTOMER_INFO_REQUIRED"] = 309] = "SERVICE_CUSTOMER_INFO_REQUIRED";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_PAUSE"] = 310] = "SERVICE_PAUSE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_PUBLISH"] = 311] = "SERVICE_PUBLISH";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_DISCOUNT"] = 312] = "SERVICE_DISCOUNT";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_ORDER_ALLOCATOR"] = 313] = "SERVICE_ORDER_ALLOCATOR";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_COMPENSATION_FUND_WITHDRAW"] = 314] = "SERVICE_COMPENSATION_FUND_WITHDRAW";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_COMPENSATION_FUND_DEPOSIT"] = 315] = "SERVICE_COMPENSATION_FUND_DEPOSIT";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_COMPENSATION_FUND_RECEIVE"] = 316] = "SERVICE_COMPENSATION_FUND_RECEIVE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_COMPENSATION_LOCKED_TIME_ADD"] = 317] = "SERVICE_COMPENSATION_LOCKED_TIME_ADD";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_REWARD"] = 318] = "SERVICE_REWARD";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_OWNER_RECEIVE"] = 319] = "SERVICE_OWNER_RECEIVE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["SERVICE_UM"] = 320] = "SERVICE_UM";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["ARBITRATION_NEW"] = 350] = "ARBITRATION_NEW";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["ARBITRATION_DESCRIPTION"] = 351] = "ARBITRATION_DESCRIPTION";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["ARBITRATION_LOCATION"] = 353] = "ARBITRATION_LOCATION";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["ARBITRATION_VOTING_GUARD"] = 354] = "ARBITRATION_VOTING_GUARD";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["ARBITRATION_USAGE_GUARD"] = 355] = "ARBITRATION_USAGE_GUARD";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["ARBITRATION_PAUSE"] = 356] = "ARBITRATION_PAUSE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["ARBITRATION_FEE"] = 357] = "ARBITRATION_FEE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["ARBITRATION_VOTE"] = 358] = "ARBITRATION_VOTE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["ARBITRATION_ARBITRATION"] = 359] = "ARBITRATION_ARBITRATION";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["ARBITRATION_FEEDBACK"] = 360] = "ARBITRATION_FEEDBACK";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["ARBITRATION_CONFIRM"] = 361] = "ARBITRATION_CONFIRM";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["ARBITRATION_VOTING_DEADLINE_CHANGE"] = 362] = "ARBITRATION_VOTING_DEADLINE_CHANGE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["ARBITRATION_RESET"] = 363] = "ARBITRATION_RESET";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["ARBITRATION_ARB_WITHDRAW"] = 364] = "ARBITRATION_ARB_WITHDRAW";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["ARBITRATION_FEES_ALLOC"] = 365] = "ARBITRATION_FEES_ALLOC";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["ARBITRATION_FEES_TRANSFER"] = 366] = "ARBITRATION_FEES_TRANSFER";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["ARBITRATION_OWNER_RECEIVE"] = 367] = "ARBITRATION_OWNER_RECEIVE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["ARBITRATION_UM"] = 368] = "ARBITRATION_UM";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["DEMAND_NEW"] = 400] = "DEMAND_NEW";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["DEMAND_DESCRIPTION"] = 401] = "DEMAND_DESCRIPTION";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["DEMAND_LOCATION"] = 402] = "DEMAND_LOCATION";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["DEMAND_GUARD"] = 404] = "DEMAND_GUARD";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["DEMAND_REWARD"] = 405] = "DEMAND_REWARD";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["DEMAND_FEEDBACK"] = 406] = "DEMAND_FEEDBACK";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["DEMAND_OWNER_RECEIVE"] = 407] = "DEMAND_OWNER_RECEIVE";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["DEMAND_UM"] = 408] = "DEMAND_UM";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["MESSNGER_NEW"] = 450] = "MESSNGER_NEW";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["MESSNGER_DESCRIPTION"] = 451] = "MESSNGER_DESCRIPTION";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["MESSNGER_LOCATION"] = 452] = "MESSNGER_LOCATION";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["MESSNGER_IM"] = 453] = "MESSNGER_IM";
+  BuiltinPermissionIndex2[BuiltinPermissionIndex2["MESSNGER_OWNER_RECEIVE"] = 454] = "MESSNGER_OWNER_RECEIVE";
+  return BuiltinPermissionIndex2;
+})(BuiltinPermissionIndex || {});
+const PermissionInfo = [
+  // Repository module permissions
+  {
+    index: 100 /* REPOSITORY_NEW */,
+    name: "repository.new",
+    description: "Create new repository",
+    object_type: ObjectType.Repository
+  },
+  {
+    index: 101 /* REPOSITORY_DESCRIPTION */,
+    name: "repository.description",
+    description: "Set repository description",
+    object_type: ObjectType.Repository
+  },
+  {
+    index: 102 /* REPOSITORY_POLICY */,
+    name: "repository.policy",
+    description: "Manage repository policies",
+    object_type: ObjectType.Repository
+  },
+  {
+    index: 103 /* REPOSITORY_REWARD */,
+    name: "repository.reward",
+    description: "Manage repository rewards",
+    object_type: ObjectType.Repository
+  },
+  {
+    index: 104 /* REPOSITORY_OWNER_RECEIVE */,
+    name: "repository.owner_receive",
+    description: "Receive objects or payments for repository",
+    object_type: ObjectType.Repository
+  },
+  {
+    index: 105 /* REPOSITORY_UM */,
+    name: "repository.um",
+    description: "Manage repository UM (User Manager)",
+    object_type: ObjectType.Repository
+  },
+  // Reward module permissions
+  {
+    index: 150 /* REWARD_NEW */,
+    name: "reward.new",
+    description: "Create new reward",
+    object_type: ObjectType.Reward
+  },
+  {
+    index: 151 /* REWARD_DESCRIPTION */,
+    name: "reward.description",
+    description: "Set reward description",
+    object_type: ObjectType.Reward
+  },
+  {
+    index: 152 /* REWARD_GUARD */,
+    name: "reward.guard",
+    description: "Manage reward guards",
+    object_type: ObjectType.Reward
+  },
+  {
+    index: 153 /* REWARD_COIN_ADD */,
+    name: "reward.coin_add",
+    description: "Add coin to reward",
+    object_type: ObjectType.Reward
+  },
+  {
+    index: 154 /* REWARD_RECEIVE */,
+    name: "reward.receive",
+    description: "Receive payment for reward",
+    object_type: ObjectType.Reward
+  },
+  {
+    index: 155 /* REWARD_GUARD_EXPIRATION_TIME_ADD */,
+    name: "reward.guard_expiration_time_add",
+    description: "Add guard expiration time",
+    object_type: ObjectType.Reward
+  },
+  {
+    index: 156 /* REWARD_OWNER_RECEIVE */,
+    name: "reward.owner_receive",
+    description: "Receive objects or payments for reward",
+    object_type: ObjectType.Reward
+  },
+  {
+    index: 157 /* REWARD_UM */,
+    name: "reward.um",
+    description: "Manage reward UM (User Manager)",
+    object_type: ObjectType.Reward
+  },
+  // Machine module permissions
+  {
+    index: 200 /* MACHINE_NEW */,
+    name: "machine.new",
+    description: "Create new machine",
+    object_type: ObjectType.Machine
+  },
+  {
+    index: 201 /* MACHINE_DESCRIPTION */,
+    name: "machine.description",
+    description: "Set machine description",
+    object_type: ObjectType.Machine
+  },
+  /*{
+  	index: BuiltinPermissionIndex.MACHINE_ENDPOINT,
+  	name: "machine.endpoint",
+  	description: "Set machine endpoint",
+  	object_type: ObjectType.Machine,
+  },*/
+  {
+    index: 203 /* MACHINE_CONSENSUS_REPOSITORIES */,
+    name: "machine.consensus_repositories",
+    description: "Manage machine consensus repositories",
+    object_type: ObjectType.Machine
+  },
+  {
+    index: 204 /* MACHINE_PAUSE */,
+    name: "machine.pause",
+    description: "Pause or resume machine",
+    object_type: ObjectType.Machine
+  },
+  {
+    index: 205 /* MACHINE_PUBLISH */,
+    name: "machine.publish",
+    description: "Publish machine",
+    object_type: ObjectType.Machine
+  },
+  {
+    index: 206 /* MACHINE_NODE */,
+    name: "machine.node",
+    description: "Manage machine nodes",
+    object_type: ObjectType.Machine
+  },
+  {
+    index: 207 /* MACHINE_OWNER_RECEIVE */,
+    name: "machine.owner_receive",
+    description: "Receive objects or payments for machine",
+    object_type: ObjectType.Machine
+  },
+  {
+    index: 208 /* MACHINE_UM */,
+    name: "machine.um",
+    description: "Manage machine UM (User Manager)",
+    object_type: ObjectType.Machine
+  },
+  // Progress module permissions
+  {
+    index: 220 /* PROGRESS_NEW */,
+    name: "progress.new",
+    description: "Create new progress",
+    object_type: ObjectType.Progress
+  },
+  {
+    index: 221 /* PROGRESS_NAMED_OPERATOR */,
+    name: "progress.namedOperator",
+    description: "Manage progress named operators (add, remove, set)",
+    object_type: ObjectType.Progress
+  },
+  {
+    index: 222 /* PROGRESS_TASK */,
+    name: "progress.task",
+    description: "Set progress task",
+    object_type: ObjectType.Progress
+  },
+  {
+    index: 223 /* PROGRESS_CONTEXT_REPOSITORY */,
+    name: "progress.context_repository",
+    description: "Manage progress context repositories (add, remove, clear)",
+    object_type: ObjectType.Progress
+  },
+  {
+    index: 224 /* PROGRESS_UNHOLD */,
+    name: "progress.unhold",
+    description: "Unhold progress",
+    object_type: ObjectType.Progress
+  },
+  {
+    index: 225 /* PROGRESS_OWNER_RECEIVE */,
+    name: "progress.owner_receive",
+    description: "Receive objects or payments for progress",
+    object_type: ObjectType.Progress
+  },
+  // Treasury module permissions
+  {
+    index: 250 /* TREASURY_NEW */,
+    name: "treasury.new",
+    description: "Create new treasury",
+    object_type: ObjectType.Treasury
+  },
+  {
+    index: 251 /* TREASURY_DESCRIPTION */,
+    name: "treasury.description",
+    description: "Set treasury description",
+    object_type: ObjectType.Treasury
+  },
+  {
+    index: 252 /* TREASURY_DEPOSIT */,
+    name: "treasury.deposit",
+    description: "Deposit coins to treasury",
+    object_type: ObjectType.Treasury
+  },
+  {
+    index: 253 /* TREASURY_RECEIVE */,
+    name: "treasury.receive",
+    description: "Receive payment for treasury",
+    object_type: ObjectType.Treasury
+  },
+  {
+    index: 254 /* TREASURY_WITHDRAW */,
+    name: "treasury.withdraw",
+    description: "Withdraw coins from treasury",
+    object_type: ObjectType.Treasury
+  },
+  {
+    index: 255 /* TREASURY_EXTERNAL_DEPOSIT */,
+    name: "treasury.external_deposit",
+    description: "External deposit to treasury",
+    object_type: ObjectType.Treasury
+  },
+  {
+    index: 256 /* TREASURY_EXTERNAL_WITHDRAW */,
+    name: "treasury.external_withdraw",
+    description: "External withdraw from treasury",
+    object_type: ObjectType.Treasury
+  },
+  {
+    index: 257 /* TREASURY_EXTERNAL_DEPOSIT_GUARD */,
+    name: "treasury.external_deposit_guard",
+    description: "Manage treasury external deposit guards",
+    object_type: ObjectType.Treasury
+  },
+  {
+    index: 258 /* TREASURY_EXTERNAL_WITHDRAW_GUARD */,
+    name: "treasury.external_withdraw_guard",
+    description: "Manage treasury external withdraw guards",
+    object_type: ObjectType.Treasury
+  },
+  {
+    index: 259 /* TREASURY_OWNER_RECEIVE */,
+    name: "treasury.owner_receive",
+    description: "Receive objects or payments for treasury",
+    object_type: ObjectType.Treasury
+  },
+  {
+    index: 260 /* TREASURY_UM */,
+    name: "treasury.um",
+    description: "Manage treasury UM (User Manager)",
+    object_type: ObjectType.Treasury
+  },
+  // Service module permissions
+  {
+    index: 300 /* SERVICE_NEW */,
+    name: "service.new",
+    description: "Create new service",
+    object_type: ObjectType.Service
+  },
+  {
+    index: 301 /* SERVICE_DESCRIPTION */,
+    name: "service.description",
+    description: "Set service description",
+    object_type: ObjectType.Service
+  },
+  /*{
+  	index: BuiltinPermissionIndex.SERVICE_ENDPOINT,
+  	name: "service.endpoint",
+  	description: "Set service endpoint",
+  	object_type: ObjectType.Service,
+  },*/
+  {
+    index: 303 /* SERVICE_LOCATION */,
+    name: "service.location",
+    description: "Set service location",
+    object_type: ObjectType.Service
+  },
+  {
+    index: 304 /* SERVICE_REPOSITORY */,
+    name: "service.repository",
+    description: "Manage service repositories",
+    object_type: ObjectType.Service
+  },
+  {
+    index: 305 /* SERVICE_SALES */,
+    name: "service.sales",
+    description: "Manage service sales",
+    object_type: ObjectType.Service
+  },
+  {
+    index: 306 /* SERVICE_MACHINE */,
+    name: "service.machine",
+    description: "Manage service machines",
+    object_type: ObjectType.Service
+  },
+  {
+    index: 307 /* SERVICE_BUY_GUARD */,
+    name: "service.buy_guard",
+    description: "Manage service buy guards",
+    object_type: ObjectType.Service
+  },
+  {
+    index: 308 /* SERVICE_ARBITRATION */,
+    name: "service.arbitration",
+    description: "Manage service arbitrations",
+    object_type: ObjectType.Service
+  },
+  {
+    index: 309 /* SERVICE_CUSTOMER_INFO_REQUIRED */,
+    name: "service.customer_info_required",
+    description: "Manage service customer info requirements",
+    object_type: ObjectType.Service
+  },
+  {
+    index: 310 /* SERVICE_PAUSE */,
+    name: "service.pause",
+    description: "Pause or resume service",
+    object_type: ObjectType.Service
+  },
+  {
+    index: 311 /* SERVICE_PUBLISH */,
+    name: "service.publish",
+    description: "Publish service",
+    object_type: ObjectType.Service
+  },
+  {
+    index: 312 /* SERVICE_DISCOUNT */,
+    name: "service.discount",
+    description: "Manage service discounts",
+    object_type: ObjectType.Service
+  },
+  {
+    index: 313 /* SERVICE_ORDER_ALLOCATOR */,
+    name: "service.order_allocator",
+    description: "Manage service order allocators",
+    object_type: ObjectType.Service
+  },
+  {
+    index: 314 /* SERVICE_COMPENSATION_FUND_WITHDRAW */,
+    name: "service.compensation_fund_withdraw",
+    description: "Withdraw from service compensation fund",
+    object_type: ObjectType.Service
+  },
+  {
+    index: 315 /* SERVICE_COMPENSATION_FUND_DEPOSIT */,
+    name: "service.compensation_fund_deposit",
+    description: "Deposit to service compensation fund",
+    object_type: ObjectType.Service
+  },
+  {
+    index: 316 /* SERVICE_COMPENSATION_FUND_RECEIVE */,
+    name: "service.compensation_fund_receive",
+    description: "Receive payments for service compensation fund",
+    object_type: ObjectType.Service
+  },
+  {
+    index: 317 /* SERVICE_COMPENSATION_LOCKED_TIME_ADD */,
+    name: "service.compensation_locked_time_add",
+    description: "Add locked time to service compensation",
+    object_type: ObjectType.Service
+  },
+  {
+    index: 318 /* SERVICE_REWARD */,
+    name: "service.reward",
+    description: "Manage service rewards",
+    object_type: ObjectType.Service
+  },
+  {
+    index: 319 /* SERVICE_OWNER_RECEIVE */,
+    name: "service.owner_receive",
+    description: "Receive objects or payments for service",
+    object_type: ObjectType.Service
+  },
+  {
+    index: 320 /* SERVICE_UM */,
+    name: "service.um",
+    description: "Manage service UM (User Manager)",
+    object_type: ObjectType.Service
+  },
+  // Arbitration module permissions
+  {
+    index: 350 /* ARBITRATION_NEW */,
+    name: "arbitration.new",
+    description: "Create new arbitration",
+    object_type: ObjectType.Arbitration
+  },
+  {
+    index: 351 /* ARBITRATION_DESCRIPTION */,
+    name: "arbitration.description",
+    description: "Set arbitration description",
+    object_type: ObjectType.Arbitration
+  },
+  /*{
+  	index: BuiltinPermissionIndex.ARBITRATION_ENDPOINT,
+  	name: "arbitration.endpoint",
+  	description: "Set arbitration endpoint",
+  	object_type: ObjectType.Arbitration,
+  },*/
+  {
+    index: 353 /* ARBITRATION_LOCATION */,
+    name: "arbitration.location",
+    description: "Set arbitration location",
+    object_type: ObjectType.Arbitration
+  },
+  {
+    index: 354 /* ARBITRATION_VOTING_GUARD */,
+    name: "arbitration.voting_guard",
+    description: "Manage arbitration voting guards",
+    object_type: ObjectType.Arbitration
+  },
+  {
+    index: 355 /* ARBITRATION_USAGE_GUARD */,
+    name: "arbitration.usage_guard",
+    description: "Set arbitration usage guard",
+    object_type: ObjectType.Arbitration
+  },
+  {
+    index: 356 /* ARBITRATION_PAUSE */,
+    name: "arbitration.pause",
+    description: "Pause or resume arbitration",
+    object_type: ObjectType.Arbitration
+  },
+  {
+    index: 357 /* ARBITRATION_FEE */,
+    name: "arbitration.fee",
+    description: "Set arbitration fee",
+    object_type: ObjectType.Arbitration
+  },
+  {
+    index: 358 /* ARBITRATION_VOTE */,
+    name: "arbitration.vote",
+    description: "Vote on arbitration",
+    object_type: ObjectType.Arbitration
+  },
+  {
+    index: 359 /* ARBITRATION_ARBITRATION */,
+    name: "arbitration.arbitration",
+    description: "Perform arbitration",
+    object_type: ObjectType.Arbitration
+  },
+  {
+    index: 360 /* ARBITRATION_FEEDBACK */,
+    name: "arbitration.feedback",
+    description: "Provide arbitration feedback",
+    object_type: ObjectType.Arbitration
+  },
+  {
+    index: 361 /* ARBITRATION_CONFIRM */,
+    name: "arbitration.confirm",
+    description: "Confirm arbitration",
+    object_type: ObjectType.Arbitration
+  },
+  {
+    index: 362 /* ARBITRATION_VOTING_DEADLINE_CHANGE */,
+    name: "arbitration.voting_deadline_change",
+    description: "Change voting deadline",
+    object_type: ObjectType.Arbitration
+  },
+  {
+    index: 363 /* ARBITRATION_RESET */,
+    name: "arbitration.reset",
+    description: "Reset arbitration",
+    object_type: ObjectType.Arbitration
+  },
+  {
+    index: 364 /* ARBITRATION_ARB_WITHDRAW */,
+    name: "arbitration.arb_withdraw",
+    description: "Withdraw arbitration",
+    object_type: ObjectType.Arbitration
+  },
+  {
+    index: 365 /* ARBITRATION_FEES_ALLOC */,
+    name: "arbitration.fees_alloc",
+    description: "Allocate arbitration fees",
+    object_type: ObjectType.Arbitration
+  },
+  {
+    index: 366 /* ARBITRATION_FEES_TRANSFER */,
+    name: "arbitration.fees_transfer",
+    description: "Transfer arbitration fees",
+    object_type: ObjectType.Arbitration
+  },
+  {
+    index: 367 /* ARBITRATION_OWNER_RECEIVE */,
+    name: "arbitration.owner_receive",
+    description: "Receive objects or payments for arbitration",
+    object_type: ObjectType.Arbitration
+  },
+  {
+    index: 368 /* ARBITRATION_UM */,
+    name: "arbitration.um",
+    description: "Manage arbitration UM (User Manager)",
+    object_type: ObjectType.Arbitration
+  },
+  // Demand module permissions
+  {
+    index: 400 /* DEMAND_NEW */,
+    name: "demand.new",
+    description: "Create new demand",
+    object_type: ObjectType.Demand
+  },
+  {
+    index: 401 /* DEMAND_DESCRIPTION */,
+    name: "demand.description",
+    description: "Set demand description",
+    object_type: ObjectType.Demand
+  },
+  {
+    index: 402 /* DEMAND_LOCATION */,
+    name: "demand.location",
+    description: "Set demand location",
+    object_type: ObjectType.Demand
+  },
+  /*{
+  	index: BuiltinPermissionIndex.DEMAND_ENDPOINT,
+  	name: "demand.endpoint",
+  	description: "Set demand endpoint",
+  	object_type: ObjectType.Demand,
+  },*/
+  {
+    index: 404 /* DEMAND_GUARD */,
+    name: "demand.guard",
+    description: "Manage demand guards",
+    object_type: ObjectType.Demand
+  },
+  {
+    index: 405 /* DEMAND_REWARD */,
+    name: "demand.reward",
+    description: "Manage demand rewards",
+    object_type: ObjectType.Demand
+  },
+  {
+    index: 406 /* DEMAND_FEEDBACK */,
+    name: "demand.feedback",
+    description: "Provide demand feedback",
+    object_type: ObjectType.Demand
+  },
+  {
+    index: 407 /* DEMAND_OWNER_RECEIVE */,
+    name: "demand.owner_receive",
+    description: "Receive objects for demand",
+    object_type: ObjectType.Demand
+  },
+  {
+    index: 408 /* DEMAND_UM */,
+    name: "demand.um",
+    description: "Manage demand UM (User Manager)",
+    object_type: ObjectType.Demand
+  },
+  // Contact module permissions
+  {
+    index: 450 /* MESSNGER_NEW */,
+    name: "messenger.new",
+    description: "Create new messenger",
+    object_type: ObjectType.Contact
+  },
+  {
+    index: 451 /* MESSNGER_DESCRIPTION */,
+    name: "messenger.description",
+    description: "Set messenger description",
+    object_type: ObjectType.Contact
+  },
+  {
+    index: 452 /* MESSNGER_LOCATION */,
+    name: "messenger.location",
+    description: "Set messenger location",
+    object_type: ObjectType.Contact
+  },
+  {
+    index: 453 /* MESSNGER_IM */,
+    name: "messenger.im",
+    description: "Manager im address",
+    object_type: ObjectType.Contact
+  },
+  {
+    index: 454 /* MESSNGER_OWNER_RECEIVE */,
+    name: "messenger.owner_receive",
+    description: "Receive objects or payments for messenger",
+    object_type: ObjectType.Contact
+  }
+];
+class CallPermission extends CallBase {
+  constructor(data) {
+    super();
+    __publicField(this, "data");
+    __publicField(this, "object_address");
+    __publicField(this, "object_data");
+    this.data = data;
+  }
+  async prepare(env) {
+    await super.prepare(env);
+    if (!this.object_address) {
+      this.object_address = await GetObjectExisted(this.data?.object);
+    }
+  }
+  async call(env) {
+    await this.prepare(env);
+    let checkOwner = false;
+    let checkAdmin = false;
+    if (this.object_address) {
+      if (this.data?.builder != null || this.data?.admin != null || this.data?.um !== void 0) {
+        checkOwner = true;
+      }
+      if (this.data?.table != null || this.data?.entity != null || this.data?.remark != null || this.data?.description != null) {
+        checkAdmin = true;
+      }
+      return await this.check_permission_and_call(
+        env,
+        this.object_address,
+        [],
+        [],
+        checkOwner,
+        checkAdmin
+      );
+    }
+    return await this.exec(env);
+  }
+  async operate(env, tx, _passport, _submission) {
+    let obj;
+    if (this.object_address) {
+      obj = toTxObject(tx, this.object_address);
+    } else {
+      obj = newPermission(tx, this.data?.description ?? "");
+    }
+    if (!obj) {
+      W_ERROR(WErrors.InvalidParam, "CallPermission_Data.data.object");
+    }
+    if (this.data?.description != null && this.object_address) {
+      descriptionSet(tx, obj, this.data.description);
+    }
+    if (this.data?.remark != null) {
+      switch (this.data.remark.op) {
+        case "set": {
+          const index = this.data.remark.index;
+          const remark = this.data.remark.remark;
+          remarkSet(tx, obj, index, remark);
+          break;
+        }
+        case "remove": {
+          const index = this.data.remark.index;
+          remarkRemove(tx, obj, index);
+          break;
+        }
+        case "clear": {
+          remarkClear(tx, obj);
+          break;
+        }
+      }
+    }
+    if (this.data?.table != null) {
+      switch (this.data.table.op) {
+        case "add perm by index": {
+          const index = this.data.table.index;
+          const entities = await GetManyAccountOrMark_Address(
+            this.data.table.entity
+          );
+          permAdd(tx, obj, index, entities);
+          break;
+        }
+        case "remove perm by index": {
+          const index = this.data.table.index;
+          const entities = await GetManyAccountOrMark_Address(
+            this.data.table.entity
+          );
+          permRemove(tx, obj, index, entities);
+          break;
+        }
+        case "set perm by index": {
+          const index = this.data.table.index;
+          const entities = await GetManyAccountOrMark_Address(
+            this.data.table.entity
+          );
+          permSet(tx, obj, index, entities);
+          break;
+        }
+        case "add perm by entity": {
+          const entity = await GetAccountOrMark_Address(
+            this.data.table.entity
+          );
+          if (entity) {
+            entityAdd(tx, obj, entity, this.data.table.index);
+          }
+          break;
+        }
+        case "remove perm by entity": {
+          const entity = await GetAccountOrMark_Address(
+            this.data.table.entity
+          );
+          if (entity) {
+            entityRemove(tx, obj, entity, this.data.table.index);
+          }
+          break;
+        }
+        case "set perm by entity": {
+          const entity = await GetAccountOrMark_Address(
+            this.data.table.entity
+          );
+          if (entity) {
+            entitySet(tx, obj, entity, this.data.table.index);
+          }
+          break;
+        }
+      }
+    }
+    if (this.data?.entity != null) {
+      switch (this.data.entity.op) {
+        case "swap": {
+          const entity1 = await GetAccountOrMark_Address(
+            this.data.entity.entity1
+          );
+          const entity2 = await GetAccountOrMark_Address(
+            this.data.entity.entity2
+          );
+          if (entity1 && entity2)
+            entitySwap(tx, obj, entity1, entity2);
+          break;
+        }
+        case "replace": {
+          const entity1 = await GetAccountOrMark_Address(
+            this.data.entity.entity1
+          );
+          const entity2 = await GetAccountOrMark_Address(
+            this.data.entity.entity2
+          );
+          if (entity1 && entity2)
+            entityReplace(tx, obj, entity1, entity2);
+          break;
+        }
+        case "copy": {
+          const entity1 = await GetAccountOrMark_Address(
+            this.data.entity.entity1
+          );
+          const entity2 = await GetAccountOrMark_Address(
+            this.data.entity.entity2
+          );
+          if (entity1 && entity2)
+            entityCopy(tx, obj, entity1, entity2);
+          break;
+        }
+        case "del": {
+          const entity = await GetAccountOrMark_Address(
+            this.data.entity.entity
+          );
+          if (entity) entityDel(tx, obj, entity);
+          break;
+        }
+      }
+    }
+    if (this.data?.admin != null) {
+      const adminAddresses = await GetManyAccountOrMark_Address(
+        this.data.admin.addresses
+      );
+      switch (this.data.admin?.op) {
+        case "add": {
+          adminAdd(tx, obj, adminAddresses);
+          break;
+        }
+        case "set": {
+          adminSet(tx, obj, adminAddresses);
+          break;
+        }
+        case "remove": {
+          adminRemove(tx, obj, adminAddresses);
+          break;
+        }
+      }
+    }
+    if (this.data?.apply != null && this.data.apply.length > 0) {
+      const r = await query_objects({
+        objects: this.data.apply,
+        no_cache: env.no_cache,
+        network: env.network
+      });
+      if (!r.objects || r.objects.length !== this.data.apply.length) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `CallPermission_Data.data.apply some objects not found ${this.data.apply}`
+        );
+      }
+      r.objects?.forEach((v) => {
+        switch (v.type) {
+          case "Demand":
+            const demand = v;
+            permission_set(
+              tx,
+              demand.object,
+              demand.permission,
+              obj,
+              parseObjectType(demand.type_raw, "demand::Demand"),
+              (name) => demandFn(name)
+            );
+            break;
+          case "Machine":
+            const machine = v;
+            permission_set(
+              tx,
+              machine.object,
+              machine.permission,
+              obj,
+              void 0,
+              (name) => machineFn(name)
+            );
+            break;
+          case "Service":
+            const service = v;
+            permission_set(
+              tx,
+              service.object,
+              service.permission,
+              obj,
+              parseObjectType(
+                service.type_raw,
+                "service::Service"
+              ),
+              (name) => serviceFn(name)
+            );
+            break;
+          case "Treasury":
+            const treasury = v;
+            permission_set(
+              tx,
+              treasury.object,
+              treasury.permission,
+              obj,
+              parseObjectType(
+                treasury.type_raw,
+                "treasury::Treasury"
+              ),
+              (name) => treasuryFn(name)
+            );
+            break;
+          case "Arbitration":
+            const arbitration = v;
+            permission_set(
+              tx,
+              arbitration.object,
+              arbitration.permission,
+              obj,
+              parseObjectType(
+                arbitration.type_raw,
+                "arbitration::Arbitration"
+              ),
+              (name) => arbitrationFn(name)
+            );
+            break;
+          case "Repository":
+            const repository = v;
+            permission_set(
+              tx,
+              repository.object,
+              repository.permission,
+              obj,
+              void 0,
+              (name) => repositoryFn(name)
+            );
+            break;
+          case "Reward":
+            const reward = v;
+            permission_set(
+              tx,
+              reward.object,
+              reward.permission,
+              obj,
+              parseObjectType(reward.type_raw, "reward::Reward"),
+              (name) => rewardFn(name)
+            );
+            break;
+        }
+      });
+    }
+    if (this.data?.builder != null) {
+      const b = await GetAccountOrMark_Address(this.data.builder);
+      if (b) transferPermission(tx, obj, b);
+    }
+    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
+        });
+      }
+      if (Array.isArray(this.data.owner_receive)) {
+        for (const item of this.data.owner_receive) {
+          if (!IsValidArgType(item.type)) {
+            W_ERROR(
+              WErrors.IsValidArgType,
+              `Invalid type: ${item.type}`
+            );
+          }
+          const r = await LocalMark.Instance().get_address(item.id);
+          if (!r) {
+            W_ERROR(
+              WErrors.IsValidArgType,
+              `Received ${item.id} is invalid`
+            );
+          }
+          ownerReceiveObject(tx, obj, r, item.type);
+        }
+      } else {
+        for (const item of this.data.owner_receive.received) {
+          const [r, p] = await Promise.all([
+            LocalMark.Instance().get_address(item.id),
+            LocalMark.Instance().get_address(item.payment)
+          ]);
+          if (!r || !p) {
+            W_ERROR(
+              WErrors.IsValidArgType,
+              `Received ${item.id} or Payment ${item.payment} is invalid`
+            );
+          }
+          ownerReceive(
+            tx,
+            obj,
+            r,
+            p,
+            this.data.owner_receive.token_type
+          );
+        }
+      }
+    }
+    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,
+            "CallPermission_Data.data.um:" + this.data.um
+          );
+        }
+      }
+      um_set(tx, obj, um_address);
+    }
+    if (!this.object_address) {
+      await this.new_with_mark(
+        env,
+        tx,
+        ObjectType.Permission,
+        create(tx, obj),
+        GetObject(this.data?.object)
+      );
+    }
+  }
+}
+function permissionFn(name) {
+  return `${PackageAddress}::permission::${name}`;
+}
+const MAX_ENTITY_COUNT = 1e3;
+const MAX_PERM_FOR_ENTITY = 1e3;
+const MAX_ADMIN_COUNT = 500;
+const USER_DEFINED_PERM_INDEX_START = 1e3;
+function isBizPermIndex(permIndex) {
+  return permIndex >= USER_DEFINED_PERM_INDEX_START;
+}
+function newPermission(tx, description) {
+  if (typeof description === "string" && !isValidDescription(description)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  return tx.moveCall({
+    target: permissionFn("new"),
+    arguments: [toTxString(tx, description)]
+  });
+}
+function create(tx, permission) {
+  return tx.moveCall({
+    target: permissionFn("create"),
+    arguments: [toTxObject(tx, permission)]
+  });
+}
+function descriptionSet(tx, permission, description) {
+  if (typeof description === "string" && !isValidDescription(description)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  tx.moveCall({
+    target: permissionFn("description_set"),
+    arguments: [toTxObject(tx, permission), toTxString(tx, description)]
+  });
+}
+function remarkSet(tx, permission, index, remark) {
+  if (typeof remark === "string" && !isValidLongName(remark)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Remark exceeds maximum length ${MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  tx.moveCall({
+    target: permissionFn("remark_set"),
+    arguments: [
+      toTxObject(tx, permission),
+      toTxU16(tx, index),
+      toTxString(tx, remark)
+    ]
+  });
+}
+function remarkRemove(tx, permission, index) {
+  tx.moveCall({
+    target: permissionFn("remark_remove"),
+    arguments: [toTxObject(tx, permission), toTxU16(tx, index)]
+  });
+}
+function remarkClear(tx, permission) {
+  tx.moveCall({
+    target: permissionFn("remark_clear"),
+    arguments: [toTxObject(tx, permission)]
+  });
+}
+function permAdd(tx, permission, permIndex, entities) {
+  tx.moveCall({
+    target: permissionFn("perm_add"),
+    arguments: [
+      toTxObject(tx, permission),
+      toTxU16(tx, permIndex),
+      toTxAddressVec(tx, entities, MAX_ENTITY_COUNT),
+      tx.object.mutRegistrar(),
+      tx.object.clock()
+    ]
+  });
+}
+function permRemove(tx, permission, permIndex, entities) {
+  tx.moveCall({
+    target: permissionFn("perm_remove"),
+    arguments: [
+      toTxObject(tx, permission),
+      toTxU16(tx, permIndex),
+      toTxAddressVec(tx, entities, MAX_ENTITY_COUNT)
+    ]
+  });
+}
+function permSet(tx, permission, permIndex, userOrGuard) {
+  tx.moveCall({
+    target: permissionFn("perm_set"),
+    arguments: [
+      toTxObject(tx, permission),
+      toTxU16(tx, permIndex),
+      toTxAddressVec(tx, userOrGuard, MAX_ENTITY_COUNT),
+      tx.object.mutRegistrar(),
+      tx.object.clock()
+    ]
+  });
+}
+function entityAdd(tx, permission, userOrGuard, perm) {
+  tx.moveCall({
+    target: permissionFn("entity_add"),
+    arguments: [
+      toTxObject(tx, permission),
+      toTxAddress(tx, userOrGuard),
+      toTxU16Vec(tx, perm, MAX_PERM_FOR_ENTITY),
+      tx.object.mutRegistrar(),
+      tx.object.clock()
+    ]
+  });
+}
+function entityRemove(tx, permission, userOrGuard, perm) {
+  tx.moveCall({
+    target: permissionFn("entity_remove"),
+    arguments: [
+      toTxObject(tx, permission),
+      toTxAddress(tx, userOrGuard),
+      toTxU16Vec(tx, perm, MAX_PERM_FOR_ENTITY)
+    ]
+  });
+}
+function entitySet(tx, permission, userOrGuard, perm) {
+  tx.moveCall({
+    target: permissionFn("entity_set"),
+    arguments: [
+      toTxObject(tx, permission),
+      toTxAddress(tx, userOrGuard),
+      toTxU16Vec(tx, perm, MAX_PERM_FOR_ENTITY),
+      tx.object.mutRegistrar(),
+      tx.object.clock()
+    ]
+  });
+}
+function entitySwap(tx, permission, userOrGuard, otherUserOrGuard) {
+  tx.moveCall({
+    target: permissionFn("entity_swap"),
+    arguments: [
+      toTxObject(tx, permission),
+      toTxAddress(tx, userOrGuard),
+      toTxAddress(tx, otherUserOrGuard),
+      tx.object.mutRegistrar(),
+      tx.object.clock()
+    ]
+  });
+}
+function entityReplace(tx, permission, userOrGuard, newUserOrGuard) {
+  tx.moveCall({
+    target: permissionFn("entity_replace"),
+    arguments: [
+      toTxObject(tx, permission),
+      toTxAddress(tx, userOrGuard),
+      toTxAddress(tx, newUserOrGuard),
+      tx.object.mutRegistrar(),
+      tx.object.clock()
+    ]
+  });
+}
+function entityDel(tx, permission, userOrGuard) {
+  tx.moveCall({
+    target: permissionFn("entity_del"),
+    arguments: [
+      toTxObject(tx, permission),
+      toTxAddress(tx, userOrGuard),
+      tx.object.mutRegistrar()
+    ]
+  });
+}
+function entityCopy(tx, permission, userOrGuard, newUserOrGuard) {
+  tx.moveCall({
+    target: permissionFn("entity_copy"),
+    arguments: [
+      toTxObject(tx, permission),
+      toTxAddress(tx, userOrGuard),
+      toTxAddress(tx, newUserOrGuard),
+      tx.object.mutRegistrar(),
+      tx.object.clock()
+    ]
+  });
+}
+function adminAdd(tx, permission, admin) {
+  tx.moveCall({
+    target: permissionFn("admin_add"),
+    arguments: [
+      toTxObject(tx, permission),
+      toTxAddressVec(tx, admin, MAX_ADMIN_COUNT)
+    ]
+  });
+}
+function adminRemove(tx, permission, admin) {
+  tx.moveCall({
+    target: permissionFn("admin_remove"),
+    arguments: [
+      toTxObject(tx, permission),
+      toTxAddressVec(tx, admin, MAX_ADMIN_COUNT)
+    ]
+  });
+}
+function adminSet(tx, permission, admin) {
+  tx.moveCall({
+    target: permissionFn("admin_set"),
+    arguments: [
+      toTxObject(tx, permission),
+      toTxAddressVec(tx, admin, MAX_ADMIN_COUNT)
+    ]
+  });
+}
+function transferPermission(tx, permission, owner) {
+  tx.moveCall({
+    target: permissionFn("transfer"),
+    arguments: [toTxObject(tx, permission), toTxAddress(tx, owner)]
+  });
+}
+function um_set(tx, permission, um) {
+  if (um) {
+    tx.moveCall({
+      target: contactFn(`permission_um_set`),
+      arguments: [
+        toTxObject(tx, um),
+        toTxObject(tx, permission),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: permissionFn(`um_none`),
+      arguments: [toTxObject(tx, permission), tx.object.mutRegistrar()]
+    });
+  }
+}
+function ownerReceiveObject(tx, permission, received, type) {
+  tx.moveCall({
+    target: permissionFn("owner_receive_object"),
+    arguments: [toTxObject(tx, permission), toTxObject(tx, received)],
+    typeArguments: [type]
+  });
+}
+function ownerReceive(tx, permission, received, payment, type) {
+  tx.moveCall({
+    target: permissionFn("owner_receive"),
+    arguments: [
+      toTxObject(tx, permission),
+      toTxObject(tx, received),
+      toTxObject(tx, payment)
+    ],
+    typeArguments: [type]
+  });
+}
+function query_permissions(filter) {
+  if (!filter) {
+    return PermissionInfo;
+  }
+  return PermissionInfo.filter((permission) => {
+    if (filter.objectType && permission.object_type !== filter.objectType) {
+      return false;
+    }
+    if (filter.name && !permission.name.includes(filter.name)) {
+      return false;
+    }
+    if (filter.index !== void 0 && permission.index !== filter.index) {
+      return false;
+    }
+    if (filter.description && !permission.description.includes(filter.description)) {
+      return false;
+    }
+    return true;
+  });
+}
+export {
+  BuiltinPermissionIndex,
+  CallPermission,
+  MAX_ADMIN_COUNT,
+  MAX_ENTITY_COUNT,
+  MAX_PERM_FOR_ENTITY,
+  PermissionInfo,
+  USER_DEFINED_PERM_INDEX_START,
+  adminAdd,
+  adminRemove,
+  adminSet,
+  create,
+  descriptionSet,
+  entityAdd,
+  entityCopy,
+  entityDel,
+  entityRemove,
+  entityReplace,
+  entitySet,
+  entitySwap,
+  isBizPermIndex,
+  newPermission,
+  ownerReceive,
+  ownerReceiveObject,
+  permAdd,
+  permRemove,
+  permSet,
+  permissionFn,
+  query_permissions,
+  remarkClear,
+  remarkRemove,
+  remarkSet,
+  transferPermission,
+  um_set
+};