@aptos-labs/ts-sdk 1.35.0-zeta.2 → 1.36.0

package/dist/esm/chunk-TDLL7QX5.mjs

@@ -1,239 +0,0 @@
-import {
-  FederatedKeylessAccount
-} from "./chunk-UGFIWCJQ.mjs";
-import {
-  KeylessAccount
-} from "./chunk-WUM247HF.mjs";
-import {
-  MultiKeyAccount
-} from "./chunk-K5OCDM3W.mjs";
-import {
-  deserializeSchemeAndAddress
-} from "./chunk-56UCIGTO.mjs";
-import {
-  SingleKeyAccount,
-  isSingleKeySigner
-} from "./chunk-G7BB6K4B.mjs";
-import {
-  Ed25519Account
-} from "./chunk-62LC4PPC.mjs";
-import {
-  EphemeralKeyPair
-} from "./chunk-XIBOO3WF.mjs";
-import {
-  MultiKey
-} from "./chunk-DMFRIING.mjs";
-import {
-  Secp256k1PrivateKey
-} from "./chunk-ECTX2FGD.mjs";
-import {
-  ZeroKnowledgeSig,
-  getIssAudAndUidVal
-} from "./chunk-T573PCIR.mjs";
-import {
-  Ed25519PrivateKey
-} from "./chunk-TFW6N66T.mjs";
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.mjs";
-import {
-  Deserializer
-} from "./chunk-NUT2VOX2.mjs";
-import {
-  Serializer
-} from "./chunk-C7T6GW5P.mjs";
-import {
-  Hex
-} from "./chunk-BDM6FBUO.mjs";
-
-// src/account/AccountUtils.ts
-function serializeKeylessAccountCommon(account, serializer) {
-  serializer.serializeStr(account.jwt);
-  serializer.serializeStr(account.uidKey);
-  serializer.serializeFixedBytes(account.pepper);
-  account.ephemeralKeyPair.serialize(serializer);
-  if (account.proof === void 0) {
-    throw new Error("Cannot serialize - proof undefined");
-  }
-  account.proof.serialize(serializer);
-  serializer.serializeOption(account.verificationKeyHash, 32);
-}
-function deserializeKeylessAccountCommon(deserializer) {
-  const jwt = deserializer.deserializeStr();
-  const uidKey = deserializer.deserializeStr();
-  const pepper = deserializer.deserializeFixedBytes(31);
-  const ephemeralKeyPair = EphemeralKeyPair.deserialize(deserializer);
-  const proof = ZeroKnowledgeSig.deserialize(deserializer);
-  const verificationKeyHash = deserializer.deserializeOption("fixedBytes", 32);
-  return { jwt, uidKey, pepper, ephemeralKeyPair, proof, verificationKeyHash };
-}
-var AccountUtils;
-((AccountUtils2) => {
-  function toBytes(account) {
-    const serializer = new Serializer();
-    serializer.serializeU32AsUleb128(account.signingScheme);
-    account.accountAddress.serialize(serializer);
-    switch (account.signingScheme) {
-      case 0 /* Ed25519 */:
-        account.privateKey.serialize(serializer);
-        return serializer.toUint8Array();
-      case 2 /* SingleKey */: {
-        if (!isSingleKeySigner(account)) {
-          throw new Error("Account is not a SingleKeySigner");
-        }
-        const anyPublicKey = account.getAnyPublicKey();
-        serializer.serializeU32AsUleb128(anyPublicKey.variant);
-        switch (anyPublicKey.variant) {
-          case 3 /* Keyless */: {
-            const keylessAccount = account;
-            serializeKeylessAccountCommon(keylessAccount, serializer);
-            return serializer.toUint8Array();
-          }
-          case 4 /* FederatedKeyless */: {
-            const federatedKeylessAccount = account;
-            serializeKeylessAccountCommon(federatedKeylessAccount, serializer);
-            federatedKeylessAccount.publicKey.jwkAddress.serialize(serializer);
-            serializer.serializeBool(federatedKeylessAccount.audless);
-            return serializer.toUint8Array();
-          }
-          case 1 /* Secp256k1 */:
-          case 0 /* Ed25519 */: {
-            const singleKeyAccount = account;
-            singleKeyAccount.privateKey.serialize(serializer);
-            return serializer.toUint8Array();
-          }
-          default: {
-            throw new Error(`Invalid public key variant: ${anyPublicKey.variant}`);
-          }
-        }
-      }
-      case 3 /* MultiKey */: {
-        const multiKeyAccount = account;
-        multiKeyAccount.publicKey.serialize(serializer);
-        serializer.serializeU32AsUleb128(multiKeyAccount.signers.length);
-        multiKeyAccount.signers.forEach((signer) => {
-          serializer.serializeFixedBytes(toBytes(signer));
-        });
-        return serializer.toUint8Array();
-      }
-      default:
-        throw new Error(`Deserialization of Account failed: invalid signingScheme value ${account.signingScheme}`);
-    }
-  }
-  AccountUtils2.toBytes = toBytes;
-  function toHexStringWithoutPrefix(account) {
-    return Hex.hexInputToStringWithoutPrefix(toBytes(account));
-  }
-  AccountUtils2.toHexStringWithoutPrefix = toHexStringWithoutPrefix;
-  function toHexString(account) {
-    return Hex.hexInputToString(toBytes(account));
-  }
-  AccountUtils2.toHexString = toHexString;
-  function deserialize(deserializer) {
-    const { address, signingScheme } = deserializeSchemeAndAddress(deserializer);
-    switch (signingScheme) {
-      case 0 /* Ed25519 */: {
-        const privateKey = Ed25519PrivateKey.deserialize(deserializer);
-        return new Ed25519Account({ privateKey, address });
-      }
-      case 2 /* SingleKey */: {
-        const variantIndex = deserializer.deserializeUleb128AsU32();
-        switch (variantIndex) {
-          case 0 /* Ed25519 */: {
-            const privateKey = Ed25519PrivateKey.deserialize(deserializer);
-            return new SingleKeyAccount({ privateKey, address });
-          }
-          case 1 /* Secp256k1 */: {
-            const privateKey = Secp256k1PrivateKey.deserialize(deserializer);
-            return new SingleKeyAccount({ privateKey, address });
-          }
-          case 3 /* Keyless */: {
-            const keylessComponents = deserializeKeylessAccountCommon(deserializer);
-            const jwtClaims = getIssAudAndUidVal(keylessComponents);
-            return new KeylessAccount({ ...keylessComponents, ...jwtClaims });
-          }
-          case 4 /* FederatedKeyless */: {
-            const keylessComponents = deserializeKeylessAccountCommon(deserializer);
-            const jwkAddress = AccountAddress.deserialize(deserializer);
-            const audless = deserializer.deserializeBool();
-            const jwtClaims = getIssAudAndUidVal(keylessComponents);
-            return new FederatedKeylessAccount({ ...keylessComponents, ...jwtClaims, jwkAddress, audless });
-          }
-          default:
-            throw new Error(`Unsupported public key variant ${variantIndex}`);
-        }
-      }
-      case 3 /* MultiKey */: {
-        const multiKey = MultiKey.deserialize(deserializer);
-        const length = deserializer.deserializeUleb128AsU32();
-        const signers = new Array();
-        for (let i = 0; i < length; i += 1) {
-          const signer = deserialize(deserializer);
-          if (!isSingleKeySigner(signer) && !(signer instanceof Ed25519Account)) {
-            throw new Error(
-              "Deserialization of MultiKeyAccount failed. Signer is not a SingleKeySigner or Ed25519Account"
-            );
-          }
-          signers.push(signer);
-        }
-        return new MultiKeyAccount({ multiKey, signers, address });
-      }
-      default:
-        throw new Error(`Deserialization of Account failed: invalid signingScheme value ${signingScheme}`);
-    }
-  }
-  AccountUtils2.deserialize = deserialize;
-  function keylessAccountFromHex(hex) {
-    const account = fromHex(hex);
-    if (!(account instanceof KeylessAccount)) {
-      throw new Error("Deserialization of KeylessAccount failed");
-    }
-    return account;
-  }
-  AccountUtils2.keylessAccountFromHex = keylessAccountFromHex;
-  function federatedKeylessAccountFromHex(hex) {
-    const account = fromHex(hex);
-    if (!(account instanceof FederatedKeylessAccount)) {
-      throw new Error("Deserialization of FederatedKeylessAccount failed");
-    }
-    return account;
-  }
-  AccountUtils2.federatedKeylessAccountFromHex = federatedKeylessAccountFromHex;
-  function multiKeyAccountFromHex(hex) {
-    const account = fromHex(hex);
-    if (!(account instanceof MultiKeyAccount)) {
-      throw new Error("Deserialization of MultiKeyAccount failed");
-    }
-    return account;
-  }
-  AccountUtils2.multiKeyAccountFromHex = multiKeyAccountFromHex;
-  function singleKeyAccountFromHex(hex) {
-    const account = fromHex(hex);
-    if (!(account instanceof SingleKeyAccount)) {
-      throw new Error("Deserialization of SingleKeyAccount failed");
-    }
-    return account;
-  }
-  AccountUtils2.singleKeyAccountFromHex = singleKeyAccountFromHex;
-  function ed25519AccountFromHex(hex) {
-    const account = fromHex(hex);
-    if (!(account instanceof Ed25519Account)) {
-      throw new Error("Deserialization of Ed25519Account failed");
-    }
-    return account;
-  }
-  AccountUtils2.ed25519AccountFromHex = ed25519AccountFromHex;
-  function fromHex(hex) {
-    return deserialize(Deserializer.fromHex(hex));
-  }
-  AccountUtils2.fromHex = fromHex;
-  function fromBytes(bytes) {
-    return fromHex(bytes);
-  }
-  AccountUtils2.fromBytes = fromBytes;
-})(AccountUtils || (AccountUtils = {}));
-
-export {
-  AccountUtils
-};
-//# sourceMappingURL=chunk-TDLL7QX5.mjs.map

package/dist/esm/chunk-TFW6N66T.mjs

@@ -1,415 +0,0 @@
-import {
-  convertSigningMessage
-} from "./chunk-THWEBWUC.mjs";
-import {
-  CKDPriv,
-  HARDENED_OFFSET,
-  deriveKey,
-  isValidHardenedPath,
-  mnemonicToSeed,
-  splitPath
-} from "./chunk-F7W7KS5C.mjs";
-import {
-  PrivateKey
-} from "./chunk-YU65LNIC.mjs";
-import {
-  AccountPublicKey
-} from "./chunk-R4JTQQBX.mjs";
-import {
-  Signature
-} from "./chunk-KLUO6XPE.mjs";
-import {
-  AuthenticationKey
-} from "./chunk-PKUXOBIV.mjs";
-import {
-  Serializable
-} from "./chunk-C7T6GW5P.mjs";
-import {
-  Hex
-} from "./chunk-BDM6FBUO.mjs";
-
-// src/core/crypto/ed25519.ts
-import { ed25519 } from "@noble/curves/ed25519";
-var L = [
-  237,
-  211,
-  245,
-  92,
-  26,
-  99,
-  18,
-  88,
-  214,
-  156,
-  247,
-  162,
-  222,
-  249,
-  222,
-  20,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  16
-];
-function isCanonicalEd25519Signature(signature) {
-  const s = signature.toUint8Array().slice(32);
-  for (let i = L.length - 1; i >= 0; i -= 1) {
-    if (s[i] < L[i]) {
-      return true;
-    }
-    if (s[i] > L[i]) {
-      return false;
-    }
-  }
-  return false;
-}
-var _Ed25519PublicKey = class _Ed25519PublicKey extends AccountPublicKey {
-  /**
-   * Creates an instance of the Ed25519Signature class from a hex input.
-   * This constructor validates the length of the signature to ensure it meets the required specifications.
-   *
-   * @param hexInput - The hex input representing the Ed25519 signature.
-   * @throws Error if the signature length is not equal to Ed25519Signature.LENGTH.
-   * @group Implementation
-   * @category Serialization
-   */
-  constructor(hexInput) {
-    super();
-    const hex = Hex.fromHexInput(hexInput);
-    if (hex.toUint8Array().length !== _Ed25519PublicKey.LENGTH) {
-      throw new Error(`PublicKey length should be ${_Ed25519PublicKey.LENGTH}`);
-    }
-    this.key = hex;
-  }
-  // region AccountPublicKey
-  /**
-   * Verifies a signed message using a public key.
-   *
-   * @param args - The arguments for verification.
-   * @param args.message - A signed message as a Hex string or Uint8Array.
-   * @param args.signature - The signature of the message.
-   * @group Implementation
-   * @category Serialization
-   */
-  verifySignature(args) {
-    const { message, signature } = args;
-    if (!isCanonicalEd25519Signature(signature)) {
-      return false;
-    }
-    const messageToVerify = convertSigningMessage(message);
-    const messageBytes = Hex.fromHexInput(messageToVerify).toUint8Array();
-    const signatureBytes = signature.toUint8Array();
-    const publicKeyBytes = this.key.toUint8Array();
-    return ed25519.verify(signatureBytes, messageBytes, publicKeyBytes);
-  }
-  /**
-   * Generates an authentication key from the public key using the Ed25519 scheme.
-   * This function is essential for creating a secure authentication key that can be used for further cryptographic operations.
-   *
-   * @returns {AuthenticationKey} The generated authentication key.
-   * @group Implementation
-   * @category Serialization
-   */
-  authKey() {
-    return AuthenticationKey.fromSchemeAndBytes({
-      scheme: 0 /* Ed25519 */,
-      input: this.toUint8Array()
-    });
-  }
-  /**
-   * Convert the internal data representation to a Uint8Array.
-   *
-   * @returns Uint8Array representation of the data.
-   * @group Implementation
-   * @category Serialization
-   */
-  toUint8Array() {
-    return this.key.toUint8Array();
-  }
-  // endregion
-  // region Serializable
-  /**
-   * Serializes the data into a byte array using the provided serializer.
-   * This allows for the conversion of data into a format suitable for transmission or storage.
-   *
-   * @param serializer - The serializer instance used to perform the serialization.
-   * @group Implementation
-   * @category Serialization
-   */
-  serialize(serializer) {
-    serializer.serializeBytes(this.key.toUint8Array());
-  }
-  /**
-   * Deserialize bytes into an Ed25519Signature object.
-   * This function is used to convert serialized byte data into a usable Ed25519Signature instance.
-   *
-   * @param deserializer - The deserializer instance used to read the byte data.
-   * @group Implementation
-   * @category Serialization
-   */
-  static deserialize(deserializer) {
-    const bytes = deserializer.deserializeBytes();
-    return new _Ed25519PublicKey(bytes);
-  }
-  // endregion
-  /**
-   * Determine if the provided public key is an instance of Ed25519PublicKey.
-   *
-   * @param publicKey - The public key to check.
-   * @returns True if the public key is an instance of Ed25519PublicKey, otherwise false.
-   * @deprecated use `instanceof Ed25519PublicKey` instead.
-   * @group Implementation
-   * @category Serialization
-   */
-  static isPublicKey(publicKey) {
-    return publicKey instanceof _Ed25519PublicKey;
-  }
-  /**
-   * Determines if the provided public key is a valid Ed25519 public key.
-   * This function checks for the presence of the "key" property and verifies that its data length matches the expected length
-   * for Ed25519 public keys.
-   *
-   * @param publicKey - The public key to validate.
-   * @returns A boolean indicating whether the public key is a valid Ed25519 public key.
-   * @group Implementation
-   * @category Serialization
-   */
-  static isInstance(publicKey) {
-    return "key" in publicKey && publicKey.key?.data?.length === _Ed25519PublicKey.LENGTH;
-  }
-};
-/**
- * Length of an Ed25519 public key
- * @group Implementation
- * @category Serialization
- */
-_Ed25519PublicKey.LENGTH = 32;
-var Ed25519PublicKey = _Ed25519PublicKey;
-var _Ed25519PrivateKey = class _Ed25519PrivateKey extends Serializable {
-  // region Constructors
-  /**
-   * Create a new PrivateKey instance from a Uint8Array or String.
-   *
-   * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
-   *
-   * @param hexInput HexInput (string or Uint8Array)
-   * @param strict If true, private key must AIP-80 compliant.
-   * @group Implementation
-   * @category Serialization
-   */
-  constructor(hexInput, strict) {
-    super();
-    const privateKeyHex = PrivateKey.parseHexInput(hexInput, "ed25519" /* Ed25519 */, strict);
-    if (privateKeyHex.toUint8Array().length !== _Ed25519PrivateKey.LENGTH) {
-      throw new Error(`PrivateKey length should be ${_Ed25519PrivateKey.LENGTH}`);
-    }
-    this.signingKey = privateKeyHex;
-  }
-  /**
-   * Generate a new random private key.
-   *
-   * @returns Ed25519PrivateKey A newly generated Ed25519 private key.
-   * @group Implementation
-   * @category Serialization
-   */
-  static generate() {
-    const keyPair = ed25519.utils.randomPrivateKey();
-    return new _Ed25519PrivateKey(keyPair, false);
-  }
-  /**
-   * Derives a private key from a mnemonic seed phrase using a specified BIP44 path.
-   * To derive multiple keys from the same phrase, change the path
-   *
-   * IMPORTANT: Ed25519 supports hardened derivation only, as it lacks a key homomorphism, making non-hardened derivation impossible.
-   *
-   * @param path - The BIP44 path used for key derivation.
-   * @param mnemonics - The mnemonic seed phrase from which the key will be derived.
-   * @throws Error if the provided path is not a valid hardened path.
-   * @group Implementation
-   * @category Serialization
-   */
-  static fromDerivationPath(path, mnemonics) {
-    if (!isValidHardenedPath(path)) {
-      throw new Error(`Invalid derivation path ${path}`);
-    }
-    return _Ed25519PrivateKey.fromDerivationPathInner(path, mnemonicToSeed(mnemonics));
-  }
-  /**
-   * Derives a child private key from a given BIP44 path and seed.
-   * A private inner function so we can separate from the main fromDerivationPath() method
-   * to add tests to verify we create the keys correctly.
-   *
-   * @param path - The BIP44 path used for key derivation.
-   * @param seed - The seed phrase created by the mnemonics, represented as a Uint8Array.
-   * @param offset - The offset used for key derivation, defaults to HARDENED_OFFSET.
-   * @returns An instance of Ed25519PrivateKey derived from the specified path and seed.
-   * @group Implementation
-   * @category Serialization
-   */
-  static fromDerivationPathInner(path, seed, offset = HARDENED_OFFSET) {
-    const { key, chainCode } = deriveKey(_Ed25519PrivateKey.SLIP_0010_SEED, seed);
-    const segments = splitPath(path).map((el) => parseInt(el, 10));
-    const { key: privateKey } = segments.reduce((parentKeys, segment) => CKDPriv(parentKeys, segment + offset), {
-      key,
-      chainCode
-    });
-    return new _Ed25519PrivateKey(privateKey, false);
-  }
-  // endregion
-  // region PrivateKey
-  /**
-   * Derive the Ed25519PublicKey for this private key.
-   *
-   * @returns Ed25519PublicKey - The derived public key corresponding to the private key.
-   * @group Implementation
-   * @category Serialization
-   */
-  publicKey() {
-    const bytes = ed25519.getPublicKey(this.signingKey.toUint8Array());
-    return new Ed25519PublicKey(bytes);
-  }
-  /**
-   * Sign the given message with the private key.
-   * This function generates a digital signature for the specified message, ensuring its authenticity and integrity.
-   *
-   * @param message - A message as a string or Uint8Array in HexInput format.
-   * @returns A digital signature for the provided message.
-   * @group Implementation
-   * @category Serialization
-   */
-  sign(message) {
-    const messageToSign = convertSigningMessage(message);
-    const messageBytes = Hex.fromHexInput(messageToSign).toUint8Array();
-    const signatureBytes = ed25519.sign(messageBytes, this.signingKey.toUint8Array());
-    return new Ed25519Signature(signatureBytes);
-  }
-  /**
-   * Get the private key in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the private key
-   * @group Implementation
-   * @category Serialization
-   */
-  toUint8Array() {
-    return this.signingKey.toUint8Array();
-  }
-  /**
-   * Get the private key as a hex string with the 0x prefix.
-   *
-   * @returns string representation of the private key.
-   * @group Implementation
-   * @category Serialization
-   */
-  toString() {
-    return this.toHexString();
-  }
-  /**
-   * Get the private key as a hex string with the 0x prefix.
-   *
-   * @returns string representation of the private key.
-   */
-  toHexString() {
-    return this.signingKey.toString();
-  }
-  /**
-   * Get the private key as a AIP-80 compliant hex string.
-   *
-   * [Read about AIP-80](https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-80.md)
-   *
-   * @returns AIP-80 compliant string representation of the private key.
-   */
-  toAIP80String() {
-    return PrivateKey.formatPrivateKey(this.signingKey.toString(), "ed25519" /* Ed25519 */);
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeBytes(this.toUint8Array());
-  }
-  static deserialize(deserializer) {
-    const bytes = deserializer.deserializeBytes();
-    return new _Ed25519PrivateKey(bytes, false);
-  }
-  // endregion
-  /**
-   * Determines if the provided private key is an instance of Ed25519PrivateKey.
-   *
-   * @param privateKey - The private key to check.
-   * @returns A boolean indicating whether the private key is an Ed25519PrivateKey.
-   *
-   * @deprecated Use `instanceof Ed25519PrivateKey` instead.
-   * @group Implementation
-   * @category Serialization
-   */
-  static isPrivateKey(privateKey) {
-    return privateKey instanceof _Ed25519PrivateKey;
-  }
-};
-/**
- * Length of an Ed25519 private key
- * @group Implementation
- * @category Serialization
- */
-_Ed25519PrivateKey.LENGTH = 32;
-/**
- * The Ed25519 key seed to use for BIP-32 compatibility
- * See more {@link https://github.com/satoshilabs/slips/blob/master/slip-0010.md}
- * @group Implementation
- * @category Serialization
- */
-_Ed25519PrivateKey.SLIP_0010_SEED = "ed25519 seed";
-var Ed25519PrivateKey = _Ed25519PrivateKey;
-var _Ed25519Signature = class _Ed25519Signature extends Signature {
-  // region Constructors
-  constructor(hexInput) {
-    super();
-    const data = Hex.fromHexInput(hexInput);
-    if (data.toUint8Array().length !== _Ed25519Signature.LENGTH) {
-      throw new Error(`Signature length should be ${_Ed25519Signature.LENGTH}`);
-    }
-    this.data = data;
-  }
-  // endregion
-  // region Signature
-  toUint8Array() {
-    return this.data.toUint8Array();
-  }
-  // endregion
-  // region Serializable
-  serialize(serializer) {
-    serializer.serializeBytes(this.data.toUint8Array());
-  }
-  static deserialize(deserializer) {
-    const bytes = deserializer.deserializeBytes();
-    return new _Ed25519Signature(bytes);
-  }
-  // endregion
-};
-/**
- * Length of an Ed25519 signature, which is 64 bytes.
- * @group Implementation
- * @category Serialization
- */
-_Ed25519Signature.LENGTH = 64;
-var Ed25519Signature = _Ed25519Signature;
-
-export {
-  isCanonicalEd25519Signature,
-  Ed25519PublicKey,
-  Ed25519PrivateKey,
-  Ed25519Signature
-};
-//# sourceMappingURL=chunk-TFW6N66T.mjs.map

package/dist/esm/chunk-THWEBWUC.mjs

@@ -1,20 +0,0 @@
-import {
-  Hex
-} from "./chunk-BDM6FBUO.mjs";
-
-// src/core/crypto/utils.ts
-var convertSigningMessage = (message) => {
-  if (typeof message === "string") {
-    const isValid = Hex.isValid(message);
-    if (!isValid.valid) {
-      return new TextEncoder().encode(message);
-    }
-    return message;
-  }
-  return message;
-};
-
-export {
-  convertSigningMessage
-};
-//# sourceMappingURL=chunk-THWEBWUC.mjs.map