wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,266 @@
+import { getFullnodeUrl, SuiClient } from "../../client/index.js";
+import { Transaction } from "../../transactions/index.js";
+import {
+  toTxObject,
+  MAX_GUARD_TABLE_ITEM_LENGTH,
+  PackageAddress,
+  parseValueType
+} from "../common.js";
+import { W_ERROR, WErrors } from "../exception.js";
+import { Account } from "../local/account.js";
+import { Config } from "../local/config.js";
+import { ObjectType, query_objects } from "../query/object.js";
+import { valueToBcsBytes } from "../util.js";
+import { getCallEnvAccount } from "./util.js";
+const MAX_GUARD_COUNT_ONCE = 20;
+const verify_guard = async (env, guard_info) => {
+  if (guard_info.guard.length > MAX_GUARD_COUNT_ONCE) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `guards invalid: guard count exceeds maximum limit ${MAX_GUARD_COUNT_ONCE}`
+    );
+  }
+  const tx = new Transaction();
+  const passport = newPassport(tx);
+  for (const v of guard_info.guard) {
+    await guardAdd(
+      tx,
+      passport,
+      v.object,
+      guard_info.submission.find((i) => i.guard === v.object)?.submission ?? [],
+      v.impack
+    );
+  }
+  verify(tx, passport);
+  freeze(tx, passport);
+  let r = await Account.Instance().sign_and_commit(
+    tx,
+    await getCallEnvAccount(env),
+    env.network
+  );
+  if (!r) {
+    W_ERROR(WErrors.Fail, "sign and commit failed");
+  }
+  if (r?.digest && !r?.objectChanges) {
+    const client = new SuiClient({
+      url: getFullnodeUrl(
+        await Config.Instance().network_get(env.network)
+      )
+    });
+    r = await client.getTransactionBlock({
+      digest: r?.digest,
+      options: { showObjectChanges: true }
+    });
+  }
+  return r;
+};
+const get_guardSubmissions = async (env, guards) => {
+  if (guards.length === 0) {
+    W_ERROR(WErrors.InvalidParam, "guards invalid: guards empty");
+  }
+  guards = [...new Set(guards)];
+  if (guards.length > MAX_GUARD_COUNT_ONCE) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `guards invalid: guard count exceeds maximum limit  ${MAX_GUARD_COUNT_ONCE} once`
+    );
+  }
+  const objects = await query_objects({
+    objects: [...guards],
+    no_cache: env.no_cache,
+    network: env.network
+  });
+  if (!objects.objects || objects.objects.length === 0) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Guard objects not found: ${guards.join(", ")}`
+    );
+  }
+  const relies = [];
+  const rep_quote = /* @__PURE__ */ new Map();
+  objects.objects.forEach((v) => {
+    if (v.type !== ObjectType.Guard) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `guards invalid: guard '${v.object}' is not a guard object`
+      );
+    }
+    const g = v;
+    g.relies?.forEach((rely) => {
+      if (!relies.includes(rely)) {
+        relies.push(rely);
+      }
+    });
+    g.rep_quote.forEach((policies, rep) => {
+      if (rep_quote.has(rep)) {
+        const r = rep_quote.get(rep) || [];
+        policies.forEach((p) => {
+          if (!r.includes(p)) {
+            r.push(p);
+          }
+        });
+        rep_quote.set(rep, r);
+      } else {
+        rep_quote.set(rep, policies);
+      }
+    });
+  });
+  const reps = await query_objects({
+    objects: [...rep_quote.keys()],
+    no_cache: env.no_cache,
+    network: env.network
+  });
+  const rep_gaurds = [];
+  reps.objects.forEach((v) => {
+    if (v.type !== ObjectType.Repository) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `rep invalid: rep '${v.object}' is not a guard object`
+      );
+    }
+    const r = v;
+    r.policies.forEach((p) => {
+      const policies = rep_quote.get(r.object) || [];
+      if (policies.includes(p.name) && p.quote_guard && !rep_gaurds.includes(p.quote_guard)) {
+        rep_gaurds.push(p.quote_guard);
+      }
+    });
+  });
+  const impact = [
+    .../* @__PURE__ */ new Set([...rep_gaurds, ...objects.objects.map((v) => v.object)])
+  ];
+  const impact_set = new Set(impact);
+  const all_guards = [
+    ...relies.filter((v) => !impact_set.has(v)).map((v) => ({ object: v, impack: false })),
+    ...impact.map((v) => ({ object: v, impack: true }))
+  ];
+  if (all_guards.length > MAX_GUARD_COUNT) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `guards invalid: guard count(include relies guards) exceeds maximum limit ${MAX_GUARD_COUNT}`
+    );
+  }
+  const remain_guards = await query_objects({
+    objects: [...relies, ...rep_gaurds],
+    no_cache: env.no_cache,
+    network: env.network
+  });
+  const submission = [];
+  remain_guards.objects.forEach((v) => {
+    const g = v;
+    const items = [];
+    g.table?.forEach((item) => {
+      if (item.b_submission) {
+        items.push(item);
+      }
+    });
+    if (items.length > 0 && submission.find((i) => i.guard === g.object) === void 0) {
+      submission.push({
+        guard: g.object,
+        submission: items
+      });
+    }
+  });
+  objects.objects.forEach((v) => {
+    const g = v;
+    const items = [];
+    g.table?.forEach((item) => {
+      if (item.b_submission) {
+        items.push(item);
+      }
+    });
+    if (items.length > 0 && submission.find((i) => i.guard === g.object) === void 0) {
+      submission.push({
+        guard: g.object,
+        submission: items
+      });
+    }
+  });
+  return {
+    type: "submission",
+    guard: all_guards,
+    submission
+  };
+};
+function passportFn(name) {
+  return `${PackageAddress}::passport::${name}`;
+}
+const MAX_GUARD_COUNT = 20;
+function newPassport(tx) {
+  return tx.moveCall({
+    target: passportFn("new"),
+    arguments: [tx.object.clock()]
+  });
+}
+function freeze(tx, passport) {
+  tx.moveCall({
+    target: passportFn("freezen"),
+    arguments: [toTxObject(tx, passport)]
+  });
+}
+function destroy(tx, passport) {
+  tx.moveCall({
+    target: passportFn("destroy"),
+    arguments: [toTxObject(tx, passport)]
+  });
+}
+const guardAdd = async (tx, passport, guard, submission, impack) => {
+  if (submission.length > MAX_GUARD_TABLE_ITEM_LENGTH) {
+    W_ERROR(
+      WErrors.GuardTableItemLengthExceeded,
+      `Submission size exceeds maximum limit ${MAX_GUARD_TABLE_ITEM_LENGTH}`
+    );
+  }
+  const identfiers = tx.pure.vector(
+    "u8",
+    submission.map((item) => item.identifier)
+  );
+  const value_bcs = [];
+  for (let i = 0; i < submission.length; i++) {
+    if (!submission[i].value) {
+      W_ERROR(
+        WErrors.IsValidValue,
+        `Value is undefined for identifier ${submission[i].identifier}`
+      );
+    }
+    const valueType = parseValueType(submission[i].value_type);
+    const bytes = await valueToBcsBytes(valueType, submission[i].value);
+    value_bcs.push(Array.from(bytes));
+  }
+  const values = tx.pure.vector("vector<u8>", value_bcs);
+  tx.moveCall({
+    target: passportFn("guard_add"),
+    arguments: [
+      toTxObject(tx, passport),
+      toTxObject(tx, guard),
+      identfiers,
+      values,
+      tx.pure.bool(impack)
+    ]
+  });
+};
+function guardClear(tx, passport) {
+  tx.moveCall({
+    target: passportFn("guard_clear"),
+    arguments: [toTxObject(tx, passport)]
+  });
+}
+function verify(tx, passport) {
+  return tx.moveCall({
+    target: passportFn("verify"),
+    arguments: [toTxObject(tx, passport)]
+  });
+}
+export {
+  MAX_GUARD_COUNT,
+  MAX_GUARD_COUNT_ONCE,
+  destroy,
+  freeze,
+  get_guardSubmissions,
+  guardAdd,
+  guardClear,
+  newPassport,
+  passportFn,
+  verify,
+  verify_guard
+};

package/dist/esm/w/call/payment.d.ts

@@ -0,0 +1,27 @@
+import type { Transaction, TransactionObjectArgument } from "../../transactions/index.js";
+import type { CallEnv, PassportObject, PaymentObject, TypeNamedObject, PaymentAddress, CoinParam } from "../common.js";
+import type { AccountOrMark_Address } from "../local/index.js";
+import type { PaymentInfo } from "../query/object.js";
+import type { CallResult } from "./base.js";
+import { CallBase } from "./base.js";
+export interface CallPayment_Data {
+    object: TypeNamedObject;
+    revenue: Revenue[];
+    info: PaymentInfo;
+}
+export declare class CallPayment extends CallBase {
+    data: CallPayment_Data;
+    constructor(data: CallPayment_Data);
+    call(env: CallEnv): Promise<CallResult>;
+    operate(env: CallEnv, tx: Transaction, _passport?: PassportObject): Promise<void>;
+}
+export declare function paymentFn(name: string): string;
+export declare const MAX_RECIPIENT_COUNT = 200;
+export interface Revenue {
+    recipient: AccountOrMark_Address;
+    amount: CoinParam;
+}
+export declare function receiveToMyself(tx: Transaction, type: string, received_object: string): void;
+export declare function paymentInfo(env: CallEnv, tx: Transaction, info: PaymentInfo): Promise<TransactionObjectArgument>;
+export declare const newPayment: (env: CallEnv, tx: Transaction, allocation_type: string, revenue: Revenue[], info: PaymentInfo) => Promise<PaymentObject>;
+export declare function create(tx: Transaction, type: string, payment: PaymentObject): PaymentAddress;

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

@@ -0,0 +1,233 @@
+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,
+  PackageAddress,
+  isValidU64,
+  isValidName,
+  MAX_NAME_LENGTH,
+  IsValidArgType,
+  ObjectType
+} from "../common.js";
+import { W_ERROR, WErrors } from "../exception.js";
+import {
+  GetAccountOrMark_Address,
+  GetManyAccountOrMark_Address
+} from "../local/index.js";
+import { LocalMark } from "../local/local.js";
+import { query_objects } from "../query/object.js";
+import { parseTypeParameter } from "../util.js";
+import { CallBase, getCoinParam } from "./base.js";
+class CallPayment extends CallBase {
+  constructor(data) {
+    super();
+    __publicField(this, "data");
+    this.data = data;
+  }
+  async call(env) {
+    return await this.exec(env);
+  }
+  async operate(env, tx, _passport) {
+    await super.prepare(env);
+    if (!IsValidArgType(this?.data?.object?.type_parameter)) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `object.type_parameter is required. such as 0x2::wow::WOW`
+      );
+    }
+    const obj = await newPayment(
+      env,
+      tx,
+      this.data.object.type_parameter,
+      this.data.revenue,
+      this.data.info
+    );
+    await this.new_with_mark(
+      env,
+      tx,
+      ObjectType.Payment,
+      create(tx, this.data.object.type_parameter, obj),
+      this.data.object
+    );
+  }
+}
+function paymentFn(name) {
+  return `${PackageAddress}::payment::${name}`;
+}
+const MAX_RECIPIENT_COUNT = 200;
+function receiveToMyself(tx, type, received_object) {
+  tx.moveCall({
+    target: paymentFn("unwrap_to_myself"),
+    arguments: [tx.object(received_object)],
+    typeArguments: [type]
+  });
+}
+async function paymentInfo(env, tx, info) {
+  if (!isValidName(info.remark)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Remark exceeds maximum length ${MAX_NAME_LENGTH}`
+    );
+  }
+  if (!isValidU64(info.index)) {
+    W_ERROR(WErrors.InvalidParam, `index: ${info.index}`);
+  }
+  info.for_guard = await LocalMark.Instance().get_address(info.for_guard);
+  if (info.for_guard) {
+    if (info.for_object) {
+      const r = await query_objects({
+        objects: [info.for_object],
+        no_cache: env.no_cache,
+        network: env.network
+      });
+      if (!r.objects || r?.objects?.length !== 1 || !r.objects[0].object) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `for_object not found: ${info.for_object}`
+        );
+      }
+      const t = parseTypeParameter(r.objects[0].type_raw);
+      return tx.moveCall({
+        target: paymentFn("payment_info_with_guard"),
+        arguments: [
+          tx.object(r.objects[0].object),
+          tx.object(info.for_guard),
+          tx.pure.string(info.remark),
+          tx.pure.u64(info.index)
+        ],
+        typeArguments: t ? [t] : []
+      });
+    } else {
+      return tx.moveCall({
+        target: paymentFn("payment_info2_with_guard"),
+        arguments: [
+          tx.object(info.for_guard),
+          tx.pure.string(info.remark),
+          tx.pure.u64(info.index)
+        ]
+      });
+    }
+  } else {
+    if (info.for_object) {
+      const r = await query_objects({
+        objects: [info.for_object],
+        no_cache: env.no_cache,
+        network: env.network
+      });
+      if (!r.objects || r?.objects?.length !== 1 || !r.objects[0].object) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `for_object not found: ${info.for_object}`
+        );
+      }
+      const t = parseTypeParameter(r.objects[0].type_raw);
+      return tx.moveCall({
+        target: paymentFn("payment_info"),
+        arguments: [
+          tx.object(r.objects[0].object),
+          tx.pure.string(info.remark),
+          tx.pure.u64(info.index)
+        ],
+        typeArguments: t ? [t] : []
+      });
+    } else {
+      return tx.moveCall({
+        target: paymentFn("payment_info2"),
+        arguments: [
+          tx.pure.string(info.remark),
+          tx.pure.u64(info.index)
+        ]
+      });
+    }
+  }
+}
+const newPayment = async (env, tx, allocation_type, revenue, info) => {
+  if (revenue.length === 1) {
+    const revenueSingle = revenue[0];
+    const recipientAddr = await GetAccountOrMark_Address(
+      revenueSingle.recipient
+    );
+    if (!recipientAddr) {
+      W_ERROR(
+        WErrors.IsValidAddress,
+        `recipient: ${revenueSingle.recipient}`
+      );
+    }
+    const coin = await getCoinParam(
+      env,
+      tx,
+      revenueSingle.amount,
+      allocation_type
+    );
+    const payment_info_obj = await paymentInfo(env, tx, info);
+    if (!payment_info_obj) {
+      W_ERROR(WErrors.InvalidParam, `payment_info_obj not created`);
+    }
+    if (!coin) {
+      W_ERROR(WErrors.InvalidParam, `coin not created`);
+    }
+    return tx.moveCall({
+      target: paymentFn("new_singleton"),
+      arguments: [
+        tx.pure.address(recipientAddr),
+        coin,
+        payment_info_obj,
+        tx.object.clock()
+      ],
+      typeArguments: [allocation_type]
+    });
+  } else {
+    const revenueArray = revenue;
+    if (revenueArray.length > MAX_RECIPIENT_COUNT) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `Recipient count exceeds maximum limit ${MAX_RECIPIENT_COUNT}`
+      );
+    }
+    if (revenueArray.length === 0) {
+      W_ERROR(WErrors.InvalidParam, `Revenue array cannot be empty`);
+    }
+    const recipientAddrs = await GetManyAccountOrMark_Address({
+      entities: revenueArray.map((item) => item.recipient),
+      check_all_founded: true
+    });
+    const amounts = revenueArray.map((item) => item.amount);
+    const coins = [];
+    for (const amount of amounts) {
+      coins.push(await getCoinParam(env, tx, amount, allocation_type));
+    }
+    return tx.moveCall({
+      target: paymentFn("new"),
+      arguments: [
+        tx.pure.vector("address", recipientAddrs),
+        tx.makeMoveVec({
+          elements: coins
+        }),
+        await paymentInfo(env, tx, info),
+        tx.object.clock()
+      ],
+      typeArguments: [allocation_type]
+    });
+  }
+};
+function create(tx, type, payment) {
+  return tx.moveCall({
+    target: paymentFn("create"),
+    arguments: [
+      toTxObject(tx, payment),
+      tx.object.mutRegistrar,
+      tx.object.clock()
+    ],
+    typeArguments: [type]
+  });
+}
+export {
+  CallPayment,
+  MAX_RECIPIENT_COUNT,
+  create,
+  newPayment,
+  paymentFn,
+  paymentInfo,
+  receiveToMyself
+};