wowok 1.8.2 → 2.1.9

package/dist/esm/utils/index.js

@@ -0,0 +1,76 @@
+import { formatAddress, formatDigest } from "./format.js";
+import {
+  isValidWowAddress,
+  isValidWowObjectId,
+  isValidTransactionDigest,
+  normalizeStructTag,
+  normalizeWowAddress,
+  normalizeWowObjectId,
+  parseStructTag,
+  WOW_ADDRESS_LENGTH
+} from "./sui-types.js";
+import {
+  fromB64,
+  toB64,
+  fromHEX,
+  toHex,
+  toHEX,
+  fromHex,
+  fromBase64,
+  toBase64,
+  fromBase58,
+  toBase58
+} from "@mysten/bcs";
+import {
+  WOW_DECIMALS,
+  MIST_PER_WOW,
+  MOVE_STDLIB_ADDRESS,
+  WOW_FRAMEWORK_ADDRESS,
+  WOW_SYSTEM_ADDRESS,
+  WOW_CLOCK_OBJECT_ID,
+  WOW_SYSTEM_MODULE_NAME,
+  WOW_TYPE_ARG,
+  WOW_SYSTEM_STATE_OBJECT_ID,
+  WOW_RANDOM_OBJECT_ID
+} from "./constants.js";
+import { isValidNamedPackage, isValidNamedType } from "./move-registry.js";
+import { deriveDynamicFieldID } from "./dynamic-fields.js";
+import { deriveObjectID } from "./derived-objects.js";
+import { normalizeTypeTag } from "../bcs/type-tag-serializer.js";
+export {
+  MIST_PER_WOW,
+  MOVE_STDLIB_ADDRESS,
+  WOW_ADDRESS_LENGTH,
+  WOW_CLOCK_OBJECT_ID,
+  WOW_DECIMALS,
+  WOW_FRAMEWORK_ADDRESS,
+  WOW_RANDOM_OBJECT_ID,
+  WOW_SYSTEM_ADDRESS,
+  WOW_SYSTEM_MODULE_NAME,
+  WOW_SYSTEM_STATE_OBJECT_ID,
+  WOW_TYPE_ARG,
+  deriveDynamicFieldID,
+  deriveObjectID,
+  formatAddress,
+  formatDigest,
+  fromB64,
+  fromBase58,
+  fromBase64,
+  fromHEX,
+  fromHex,
+  isValidNamedPackage,
+  isValidNamedType,
+  isValidTransactionDigest,
+  isValidWowAddress,
+  isValidWowObjectId,
+  normalizeStructTag,
+  normalizeTypeTag,
+  normalizeWowAddress,
+  normalizeWowObjectId,
+  parseStructTag,
+  toB64,
+  toBase58,
+  toBase64,
+  toHEX,
+  toHex
+};

package/dist/esm/utils/move-registry.d.ts

@@ -0,0 +1,6 @@
+export declare const isValidNamedPackage: (name: string) => boolean;
+/**
+ * Checks if a type contains valid named packages.
+ * This DOES NOT check if the type is a valid Move type.
+ */
+export declare const isValidNamedType: (type: string) => boolean;

package/dist/esm/utils/move-registry.js

@@ -0,0 +1,24 @@
+import { isValidSuiNSName } from "./suins.js";
+const NAME_PATTERN = /^([a-z0-9]+(?:-[a-z0-9]+)*)$/;
+const VERSION_REGEX = /^\d+$/;
+const MAX_APP_SIZE = 64;
+const NAME_SEPARATOR = "/";
+const isValidNamedPackage = (name) => {
+  const parts = name.split(NAME_SEPARATOR);
+  if (parts.length < 2 || parts.length > 3) return false;
+  const [org, app, version] = parts;
+  if (version !== void 0 && !VERSION_REGEX.test(version)) return false;
+  if (!isValidSuiNSName(org)) return false;
+  return NAME_PATTERN.test(app) && app.length < MAX_APP_SIZE;
+};
+const isValidNamedType = (type) => {
+  const splitType = type.split(/::|<|>|,/);
+  for (const t of splitType) {
+    if (t.includes(NAME_SEPARATOR) && !isValidNamedPackage(t)) return false;
+  }
+  return true;
+};
+export {
+  isValidNamedPackage,
+  isValidNamedType
+};

package/dist/esm/utils/sui-types.d.ts

@@ -0,0 +1,26 @@
+/** Returns whether the tx digest is valid based on the serialization format */
+export declare function isValidTransactionDigest(value: string): value is string;
+export declare const WOW_ADDRESS_LENGTH = 32;
+export declare function isValidWowAddress(value: string): value is string;
+export declare function isValidWowObjectId(value: string): boolean;
+export type StructTag = {
+    address: string;
+    module: string;
+    name: string;
+    typeParams: (string | StructTag)[];
+};
+export declare function parseStructTag(type: string): StructTag;
+export declare function normalizeStructTag(type: string | StructTag): string;
+/**
+ * Perform the following operations:
+ * 1. Make the address lower case
+ * 2. Prepend `0x` if the string does not start with `0x`.
+ * 3. Add more zeros if the length of the address(excluding `0x`) is less than `WOW_ADDRESS_LENGTH`
+ *
+ * WARNING: if the address value itself starts with `0x`, e.g., `0x0x`, the default behavior
+ * is to treat the first `0x` not as part of the address. The default behavior can be overridden by
+ * setting `forceAdd0x` to true
+ *
+ */
+export declare function normalizeWowAddress(value: string, forceAdd0x?: boolean): string;
+export declare function normalizeWowObjectId(value: string, forceAdd0x?: boolean): string;

package/dist/esm/utils/sui-types.js

@@ -0,0 +1,70 @@
+import { fromBase58, splitGenericParameters } from "@mysten/bcs";
+import { isValidNamedPackage } from "./move-registry.js";
+const TX_DIGEST_LENGTH = 32;
+function isValidTransactionDigest(value) {
+  try {
+    const buffer = fromBase58(value);
+    return buffer.length === TX_DIGEST_LENGTH;
+  } catch {
+    return false;
+  }
+}
+const WOW_ADDRESS_LENGTH = 32;
+function isValidWowAddress(value) {
+  return isHex(value) && getHexByteLength(value) === WOW_ADDRESS_LENGTH;
+}
+function isValidWowObjectId(value) {
+  return isValidWowAddress(value);
+}
+function parseTypeTag(type) {
+  if (!type.includes("::")) return type;
+  return parseStructTag(type);
+}
+function parseStructTag(type) {
+  const [address, module] = type.split("::");
+  const isMvrPackage = isValidNamedPackage(address);
+  const rest = type.slice(address.length + module.length + 4);
+  const name = rest.includes("<") ? rest.slice(0, rest.indexOf("<")) : rest;
+  const typeParams = rest.includes("<") ? splitGenericParameters(
+    rest.slice(rest.indexOf("<") + 1, rest.lastIndexOf(">"))
+  ).map((typeParam) => parseTypeTag(typeParam.trim())) : [];
+  return {
+    address: isMvrPackage ? address : normalizeWowAddress(address),
+    module,
+    name,
+    typeParams
+  };
+}
+function normalizeStructTag(type) {
+  const { address, module, name, typeParams } = typeof type === "string" ? parseStructTag(type) : type;
+  const formattedTypeParams = typeParams?.length > 0 ? `<${typeParams.map(
+    (typeParam) => typeof typeParam === "string" ? typeParam : normalizeStructTag(typeParam)
+  ).join(",")}>` : "";
+  return `${address}::${module}::${name}${formattedTypeParams}`;
+}
+function normalizeWowAddress(value, forceAdd0x = false) {
+  let address = value.toLowerCase();
+  if (!forceAdd0x && address.startsWith("0x")) {
+    address = address.slice(2);
+  }
+  return `0x${address.padStart(WOW_ADDRESS_LENGTH * 2, "0")}`;
+}
+function normalizeWowObjectId(value, forceAdd0x = false) {
+  return normalizeWowAddress(value, forceAdd0x);
+}
+function isHex(value) {
+  return /^(0x|0X)?[a-fA-F0-9]+$/.test(value) && value.length % 2 === 0;
+}
+function getHexByteLength(value) {
+  return /^(0x|0X)/.test(value) ? (value.length - 2) / 2 : value.length / 2;
+}
+export {
+  WOW_ADDRESS_LENGTH,
+  isValidTransactionDigest,
+  isValidWowAddress,
+  isValidWowObjectId,
+  normalizeStructTag,
+  normalizeWowAddress,
+  normalizeWowObjectId,
+  parseStructTag
+};

package/dist/esm/utils/suins.d.ts

@@ -0,0 +1,2 @@
+export declare function isValidSuiNSName(name: string): boolean;
+export declare function normalizeSuiNSName(name: string, format?: "at" | "dot"): string;

package/dist/esm/utils/suins.js

@@ -0,0 +1,36 @@
+const SUI_NS_NAME_REGEX = /^(?!.*(^(?!@)|[-.@])($|[-.@]))(?:[a-z0-9-]{0,63}(?:\.[a-z0-9-]{0,63})*)?@[a-z0-9-]{0,63}$/i;
+const SUI_NS_DOMAIN_REGEX = /^(?!.*(^|[-.])($|[-.]))(?:[a-z0-9-]{0,63}\.)+sui$/i;
+const MAX_SUI_NS_NAME_LENGTH = 235;
+function isValidSuiNSName(name) {
+  if (name.length > MAX_SUI_NS_NAME_LENGTH) {
+    return false;
+  }
+  if (name.includes("@")) {
+    return SUI_NS_NAME_REGEX.test(name);
+  }
+  return SUI_NS_DOMAIN_REGEX.test(name);
+}
+function normalizeSuiNSName(name, format = "at") {
+  const lowerCase = name.toLowerCase();
+  let parts;
+  if (lowerCase.includes("@")) {
+    if (!SUI_NS_NAME_REGEX.test(lowerCase)) {
+      throw new Error(`Invalid SuiNS name ${name}`);
+    }
+    const [labels, domain] = lowerCase.split("@");
+    parts = [...labels ? labels.split(".") : [], domain];
+  } else {
+    if (!SUI_NS_DOMAIN_REGEX.test(lowerCase)) {
+      throw new Error(`Invalid SuiNS name ${name}`);
+    }
+    parts = lowerCase.split(".").slice(0, -1);
+  }
+  if (format === "dot") {
+    return `${parts.join(".")}.sui`;
+  }
+  return `${parts.slice(0, -1).join(".")}@${parts[parts.length - 1]}`;
+}
+export {
+  isValidSuiNSName,
+  normalizeSuiNSName
+};

package/dist/esm/verify/index.d.ts

@@ -0,0 +1 @@
+export { verifySignature, verifyPersonalMessageSignature, verifyTransactionSignature, publicKeyFromRawBytes, publicKeyFromSuiBytes, } from "./verify.js";

package/dist/esm/verify/index.js

@@ -0,0 +1,14 @@
+import {
+  verifySignature,
+  verifyPersonalMessageSignature,
+  verifyTransactionSignature,
+  publicKeyFromRawBytes,
+  publicKeyFromSuiBytes
+} from "./verify.js";
+export {
+  publicKeyFromRawBytes,
+  publicKeyFromSuiBytes,
+  verifyPersonalMessageSignature,
+  verifySignature,
+  verifyTransactionSignature
+};

package/dist/esm/verify/verify.d.ts

@@ -0,0 +1,16 @@
+import type { PublicKey, SignatureScheme } from "../cryptography/index.js";
+export declare function verifySignature(bytes: Uint8Array, signature: string, options?: {
+    address?: string;
+}): Promise<PublicKey>;
+export declare function verifyPersonalMessageSignature(message: Uint8Array, signature: string, options?: {
+    address?: string;
+}): Promise<PublicKey>;
+export declare function verifyTransactionSignature(transaction: Uint8Array, signature: string, options?: {
+    address?: string;
+}): Promise<PublicKey>;
+export declare function publicKeyFromRawBytes(signatureScheme: SignatureScheme, bytes: Uint8Array, options?: {
+    address?: string;
+}): PublicKey;
+export declare function publicKeyFromSuiBytes(publicKey: string | Uint8Array, options?: {
+    address?: string;
+}): PublicKey;

package/dist/esm/verify/verify.js

@@ -0,0 +1,108 @@
+import { fromBase64 } from "@mysten/bcs";
+import {
+  parseSerializedSignature,
+  SIGNATURE_FLAG_TO_SCHEME
+} from "../cryptography/index.js";
+import { Ed25519PublicKey } from "../keypairs/ed25519/publickey.js";
+import { PasskeyPublicKey } from "../keypairs/passkey/publickey.js";
+import { Secp256k1PublicKey } from "../keypairs/secp256k1/publickey.js";
+import { Secp256r1PublicKey } from "../keypairs/secp256r1/publickey.js";
+import { MultiSigPublicKey } from "../multisig/publickey.js";
+async function verifySignature(bytes, signature, options) {
+  const parsedSignature = parseSignature(signature);
+  if (!await parsedSignature.publicKey.verify(
+    bytes,
+    parsedSignature.serializedSignature
+  )) {
+    throw new Error(`Signature is not valid for the provided data`);
+  }
+  if (options?.address && !parsedSignature.publicKey.verifyAddress(options.address)) {
+    throw new Error(`Signature is not valid for the provided address`);
+  }
+  return parsedSignature.publicKey;
+}
+async function verifyPersonalMessageSignature(message, signature, options) {
+  const parsedSignature = parseSignature(signature);
+  if (!await parsedSignature.publicKey.verifyPersonalMessage(
+    message,
+    parsedSignature.serializedSignature
+  )) {
+    throw new Error(`Signature is not valid for the provided message`);
+  }
+  if (options?.address && !parsedSignature.publicKey.verifyAddress(options.address)) {
+    throw new Error(`Signature is not valid for the provided address`);
+  }
+  return parsedSignature.publicKey;
+}
+async function verifyTransactionSignature(transaction, signature, options) {
+  const parsedSignature = parseSignature(signature);
+  if (!await parsedSignature.publicKey.verifyTransaction(
+    transaction,
+    parsedSignature.serializedSignature
+  )) {
+    throw new Error(`Signature is not valid for the provided Transaction`);
+  }
+  if (options?.address && !parsedSignature.publicKey.verifyAddress(options.address)) {
+    throw new Error(`Signature is not valid for the provided address`);
+  }
+  return parsedSignature.publicKey;
+}
+function parseSignature(signature) {
+  const parsedSignature = parseSerializedSignature(signature);
+  if (parsedSignature.signatureScheme === "MultiSig") {
+    return {
+      ...parsedSignature,
+      publicKey: new MultiSigPublicKey(
+        parsedSignature.multisig.multisig_pk
+      )
+    };
+  }
+  const publicKey = publicKeyFromRawBytes(
+    parsedSignature.signatureScheme,
+    parsedSignature.publicKey
+  );
+  return {
+    ...parsedSignature,
+    publicKey
+  };
+}
+function publicKeyFromRawBytes(signatureScheme, bytes, options) {
+  let publicKey;
+  switch (signatureScheme) {
+    case "ED25519":
+      publicKey = new Ed25519PublicKey(bytes);
+      break;
+    case "Secp256k1":
+      publicKey = new Secp256k1PublicKey(bytes);
+      break;
+    case "Secp256r1":
+      publicKey = new Secp256r1PublicKey(bytes);
+      break;
+    case "MultiSig":
+      publicKey = new MultiSigPublicKey(bytes);
+      break;
+    case "ZkLogin":
+      throw new Error(`ZkLogin signature scheme is not supported`);
+    case "Passkey":
+      publicKey = new PasskeyPublicKey(bytes);
+      break;
+    default:
+      throw new Error(`Unsupported signature scheme ${signatureScheme}`);
+  }
+  if (options?.address && !publicKey.verifyAddress(options.address)) {
+    throw new Error(`Public key bytes do not match the provided address`);
+  }
+  return publicKey;
+}
+function publicKeyFromSuiBytes(publicKey, options) {
+  const bytes = typeof publicKey === "string" ? fromBase64(publicKey) : publicKey;
+  const signatureScheme = SIGNATURE_FLAG_TO_SCHEME[bytes[0]];
+  return publicKeyFromRawBytes(signatureScheme, bytes.slice(1), options);
+}
+export {
+  publicKeyFromRawBytes,
+  publicKeyFromSuiBytes,
+  verifyPersonalMessageSignature,
+  verifySignature,
+  verifyTransactionSignature
+};

package/dist/esm/version.d.ts

@@ -0,0 +1,2 @@
+export declare const PACKAGE_VERSION = "2.1.9";
+export declare const TARGETED_RPC_VERSION = "0.60.1";

package/dist/esm/version.js

@@ -0,0 +1,6 @@
+const PACKAGE_VERSION = "2.1.9";
+const TARGETED_RPC_VERSION = "0.60.1";
+export {
+  PACKAGE_VERSION,
+  TARGETED_RPC_VERSION
+};

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

@@ -0,0 +1,35 @@
+import type { Transaction, TransactionObjectArgument, TransactionResult } from "../../transactions/index.js";
+import type { CallEnv, PassportObject, GuardObject, PaymentInfoObject, PaymentObject, AllocationObject, CoinObject, TypeNamedObject, AllocationAddress, ReceivedObject, CoinParam } from "../common.js";
+import type { AllocationSharing, Allocators, PaymentInfo } from "../query/object.js";
+import type { ReceivedBalanceOrRecently } from "../query/received.js";
+import type { CallResult } from "./base.js";
+import { CallBase } from "./base.js";
+export type CallAllocation_Data = {
+    object: TypeNamedObject;
+    allocators: Allocators;
+    coin: CoinParam;
+    payment_info: PaymentInfo;
+} | {
+    object: string;
+    received_coins?: ReceivedBalanceOrRecently;
+    alloc_by_guard?: string;
+};
+export declare class CallAllocation extends CallBase {
+    data: CallAllocation_Data;
+    object_address: string | undefined;
+    type_parameter: string | undefined;
+    constructor(data: CallAllocation_Data);
+    protected prepare(env: CallEnv): Promise<void>;
+    call(env: CallEnv): Promise<CallResult>;
+    operate(env: CallEnv, tx: Transaction, passport?: PassportObject): Promise<void>;
+}
+export declare function allocationFn(name: string): string;
+export declare const MAX_ALLOCATOR_COUNT = 100;
+export declare const MAX_SHARING_COUNT = 100;
+export type AllocatorsType = TransactionObjectArgument;
+export declare const sharing: (tx: Transaction, sharing: AllocationSharing, preResolvedAddress?: string) => Promise<TransactionResult>;
+export declare const allocators: (tx: Transaction, param: Allocators) => Promise<AllocatorsType>;
+export declare function alloc(tx: Transaction, allocation: AllocationObject, allocation_type: string, guard: GuardObject, passport: PassportObject): void;
+export declare function newAllocation(tx: Transaction, allocation_type: string, coin: CoinObject, allocators: TransactionObjectArgument): AllocationObject;
+export declare function create(tx: Transaction, allocation: TransactionObjectArgument, allocation_type: string, paymentInfo: PaymentInfoObject): AllocationAddress;
+export declare function receive(tx: Transaction, allocation: AllocationObject, allocation_type: string, received: ReceivedObject, payment: PaymentObject): TransactionResult;