@aptos-labs/ts-sdk 1.8.0 → 1.9.1-plugin.0

package/dist/esm/core/crypto/asymmetricCrypto.d.mts

@@ -1,74 +0,0 @@
-import { HexInput } from '../../types/index.mjs';
-import { Serializable, Serializer } from '../../bcs/serializer.mjs';
-import '../../utils/apiEndpoints.mjs';
-import '../../types/indexer.mjs';
-import '../../types/generated/operations.mjs';
-import '../../types/generated/types.mjs';
-import '../hex.mjs';
-import '../common.mjs';
-
-/**
- * An abstract representation of a public key.  All Asymmetric key pairs will use this to
- * verify signatures and for authentication keys.
- */
-declare abstract class PublicKey extends Serializable {
-    /**
-     * Verifies that the private key associated with this public key signed the message with the given signature.
-     * @param args.message The message that was signed
-     * @param args.signature The signature to verify
-     */
-    abstract verifySignature(args: {
-        message: HexInput;
-        signature: Signature;
-    }): boolean;
-    /**
-     * Get the raw public key bytes
-     */
-    abstract toUint8Array(): Uint8Array;
-    /**
-     * Get the public key as a hex string with a 0x prefix e.g. 0x123456...
-     */
-    abstract toString(): string;
-    abstract serialize(serializer: Serializer): void;
-}
-/**
- * An abstract representation of a private key.  This is used to sign transactions and
- * derive the public key associated.
- */
-declare abstract class PrivateKey extends Serializable {
-    /**
-     * Sign a message with the key
-     * @param message The message to sign
-     */
-    abstract sign(message: HexInput): Signature;
-    /**
-     * Get the raw private key bytes
-     */
-    abstract toUint8Array(): Uint8Array;
-    /**
-     * Get the private key as a hex string with a 0x prefix e.g. 0x123456...
-     */
-    abstract toString(): string;
-    abstract serialize(serializer: Serializer): void;
-    /**
-     * Derives the public key associated with the private key
-     */
-    abstract publicKey(): PublicKey;
-}
-/**
- * An abstract representation of a signature.  This is the product of signing a
- * message and can be used with the PublicKey to verify the signature.
- */
-declare abstract class Signature extends Serializable {
-    /**
-     * Get the raw signature bytes
-     */
-    abstract toUint8Array(): Uint8Array;
-    /**
-     * Get the signature as a hex string with a 0x prefix e.g. 0x123456...
-     */
-    abstract toString(): string;
-    abstract serialize(serializer: Serializer): void;
-}
-
-export { PrivateKey, PublicKey, Signature };

package/dist/esm/core/crypto/asymmetricCrypto.mjs

@@ -1,2 +0,0 @@
-import{a,b,c}from"../../chunk-V6JFR2CB.mjs";import"../../chunk-FZY4PMEE.mjs";import"../../chunk-PPTG6BDV.mjs";import"../../chunk-B2ZKW23W.mjs";import"../../chunk-F7MOQC7Z.mjs";import"../../chunk-VRSUCKJA.mjs";import"../../chunk-6IFMQ5AS.mjs";import"../../chunk-N4RBQZ2B.mjs";import"../../chunk-NL72WE3E.mjs";import"../../chunk-FBPNHF54.mjs";import"../../chunk-56CNRT2K.mjs";import"../../chunk-CVEJHRAU.mjs";import"../../chunk-4WPQQPUF.mjs";import"../../chunk-FVA2OPG4.mjs";export{b as PrivateKey,a as PublicKey,c as Signature};
-//# sourceMappingURL=asymmetricCrypto.mjs.map

package/src/core/account.ts

@@ -1,282 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-import { AccountAddress } from "./accountAddress";
-import { AuthenticationKey } from "./authenticationKey";
-import { PrivateKey, PublicKey, Signature } from "./crypto/asymmetricCrypto";
-import { Ed25519PrivateKey, Ed25519PublicKey } from "./crypto/ed25519";
-import { MultiEd25519PublicKey } from "./crypto/multiEd25519";
-import { Secp256k1PrivateKey, Secp256k1PublicKey } from "./crypto/secp256k1";
-import { Hex } from "./hex";
-import { GenerateAccount, HexInput, SigningScheme, SigningSchemeInput } from "../types";
-import { AnyPublicKey } from "./crypto/anyPublicKey";
-
-/**
- * Class for creating and managing account on Aptos network
- *
- * Use this class to create accounts, sign transactions, and more.
- * Note: Creating an account instance does not create the account on-chain.
- *
- * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports
- * `Legacy` and `Unified` authentications.
- *
- * @Legacy includes `ED25519` and `MultiED25519`
- * @Unified includes `SingleSender` and `MultiSender`, where currently
- * `SingleSender` supports `ED25519` and `Secp256k1`, and `MultiSender` supports
- * `MultiED25519`.
- *
- * In TypeScript SDK, we support all of these options:
- *
- * @generate default to generate Legacy Ed25519 keys, with an optional `legacy` boolean argument
- * that lets you generate new keys conforming to the Unified authentication.
- *
- * @fromPrivateKey derives an account by a provided private key and address, with an optional
- * `legacy` boolean argument that lets you generate new keys conforming to the Unified authentication.
- *
- * @fromDerivationPath derives an account with bip44 path and mnemonics,
- *
- */
-export class Account {
-  /**
-   * Public key associated with the account
-   */
-  readonly publicKey: PublicKey;
-
-  /**
-   * Private key associated with the account
-   */
-  readonly privateKey: PrivateKey;
-
-  /**
-   * Account address associated with the account
-   */
-  readonly accountAddress: AccountAddress;
-
-  /**
-   * Signing scheme used to sign transactions
-   */
-  readonly signingScheme: SigningScheme;
-
-  /**
-   * constructor for Account
-   *
-   * Need to update this to use the new crypto library if new schemes are added.
-   *
-   * @param args.privateKey PrivateKey - private key of the account
-   * @param args.address AccountAddress - address of the account
-   * @param args.legacy optional. If set to false, the keypair authentication keys will be derived with a unified scheme.
-   * Defaults to deriving an authentication key with the legacy scheme.
-   *
-   * This method is private because it should only be called by the factory static methods.
-   * @returns Account
-   */
-  private constructor(args: { privateKey: PrivateKey; address: AccountAddress; legacy?: boolean }) {
-    const { privateKey, address, legacy } = args;
-    const useLegacy = legacy ?? true;
-
-    // Derive the public key from the private key
-    this.publicKey = privateKey.publicKey();
-
-    // Derive the signing scheme from the public key
-    if (this.publicKey instanceof Ed25519PublicKey) {
-      if (useLegacy) {
-        this.signingScheme = SigningScheme.Ed25519;
-      } else {
-        this.publicKey = new AnyPublicKey(this.publicKey);
-        this.signingScheme = SigningScheme.SingleKey;
-      }
-    } else if (this.publicKey instanceof MultiEd25519PublicKey) {
-      this.signingScheme = SigningScheme.MultiEd25519;
-    } else if (this.publicKey instanceof Secp256k1PublicKey) {
-      this.publicKey = new AnyPublicKey(this.publicKey);
-      this.signingScheme = SigningScheme.SingleKey;
-    } else {
-      throw new Error("Can not create new Account, unsupported public key type");
-    }
-
-    this.privateKey = privateKey;
-    this.accountAddress = address;
-  }
-
-  /**
-   * Derives an account with random private key and address.
-   *
-   * Default generation is using the Legacy ED25519 key
-   *
-   * @param args optional. Unify GenerateAccount type for Legacy and Unified keys
-   *
-   * Account input type to generate an account using Legacy
-   * Ed25519 or MultiEd25519 keys or without a specified `scheme`.
-   * ```
-   * GenerateAccountWithLegacyKey = {
-   *  scheme?: SigningSchemeInput.Ed25519 | SigningSchemeInput.MultiEd25519;
-   *  legacy: true;
-   * };
-   * ```
-   *
-   * Account input type to generate an account using Unified
-   * Secp256k1Ecdsa key
-   * In this case `legacy` is always false
-   * ```
-   * GenerateAccountWithUnifiedKey = {
-   *  scheme: SigningSchemeInput.Secp256k1Ecdsa;
-   *  legacy?: false;
-   * };
-   * ```
-   *
-   * @returns Account with the given signing scheme
-   */
-  static generate(args?: GenerateAccount): Account {
-    const useLegacy = args?.legacy ?? true;
-
-    let privateKey: PrivateKey;
-    let publicKey: PublicKey;
-
-    switch (args?.scheme) {
-      case SigningSchemeInput.Secp256k1Ecdsa:
-        privateKey = Secp256k1PrivateKey.generate();
-        publicKey = new AnyPublicKey(privateKey.publicKey());
-        break;
-      default:
-        privateKey = Ed25519PrivateKey.generate();
-        if (useLegacy === false) {
-          publicKey = new AnyPublicKey(privateKey.publicKey());
-        } else {
-          publicKey = privateKey.publicKey();
-        }
-    }
-    const authKey = AuthenticationKey.fromPublicKey({ publicKey });
-
-    const address = authKey.derivedAddress();
-    return new Account({ privateKey, address, legacy: args?.legacy });
-  }
-
-  /**
-   * Instantiates an account given a private key.
-   *
-   * This is used as a local calculation and therefore is used to instantiate an `Account`
-   * that has not had its authentication key rotated.
-   *
-   * @param privateKey PrivateKey - private key of the account
-   * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults
-   * to generating a Legacy Ed25519 keypair
-   *
-   * @returns Account
-   */
-  static fromPrivateKey(args: { privateKey: PrivateKey; legacy?: boolean }): Account {
-    const { privateKey, legacy } = args;
-    const useLegacy = legacy ?? true;
-
-    let publicKey;
-    if (privateKey instanceof Secp256k1PrivateKey) {
-      // Secp256k1 single sender
-      publicKey = new AnyPublicKey(privateKey.publicKey());
-    } else if (privateKey instanceof Ed25519PrivateKey) {
-      // legacy Ed25519
-      if (useLegacy) {
-        publicKey = privateKey.publicKey();
-      } else {
-        // Ed25519 single sender
-        publicKey = new AnyPublicKey(privateKey.publicKey());
-      }
-    } else {
-      throw new Error(`Unsupported private key ${privateKey}`);
-    }
-
-    const authKey = AuthenticationKey.fromPublicKey({ publicKey });
-    const address = authKey.derivedAddress();
-    return new Account({ privateKey, address, legacy: useLegacy });
-  }
-
-  /**
-   * Instantiates an account given a private key and a specified account address.
-   * This is primarily used to instantiate an `Account` that has had its authentication key rotated.
-   *
-   * @param args.privateKey PrivateKey - the underlying private key for the account
-   * @param args.address AccountAddress - The account address the `Account` will sign for
-   * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults
-   * to generating a Legacy Ed25519 keypair
-   *
-   * @returns Account
-   */
-  static fromPrivateKeyAndAddress(args: {
-    privateKey: PrivateKey;
-    address: AccountAddress;
-    legacy?: boolean;
-  }): Account {
-    const { privateKey, address, legacy } = args;
-    return new Account({ privateKey, address, legacy });
-  }
-
-  /**
-   * Derives an account with bip44 path and mnemonics,
-   *
-   * @param args.scheme The signing scheme to derive with
-   * @param args.path the BIP44 derive hardened path (e.g. m/44'/637'/0'/0'/0') for Ed25519,
-   * or non-hardened path (e.g. m/44'/637'/0'/0/0) for secp256k1
-   * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
-   * @param args.mnemonic the mnemonic seed phrase of the account
-   * @param args.legacy optional. If set to false, the keypair generated is a Unified keypair. Defaults
-   * to generating a Legacy Ed25519 keypair
-   *
-   * @returns Account
-   */
-  static fromDerivationPath(args: {
-    scheme: SigningSchemeInput;
-    path: string;
-    mnemonic: string;
-    legacy?: boolean;
-  }): Account {
-    const { path, mnemonic, scheme, legacy } = args;
-    let privateKey: PrivateKey;
-    switch (scheme) {
-      case SigningSchemeInput.Secp256k1Ecdsa:
-        privateKey = Secp256k1PrivateKey.fromDerivationPath(path, mnemonic);
-        break;
-      case SigningSchemeInput.Ed25519:
-        privateKey = Ed25519PrivateKey.fromDerivationPath(path, mnemonic);
-        break;
-      default:
-        throw new Error(`Unsupported scheme ${scheme}`);
-    }
-    return Account.fromPrivateKey({ privateKey, legacy });
-  }
-
-  /**
-   * This key enables account owners to rotate their private key(s)
-   * associated with the account without changing the address that hosts their account.
-   * See here for more info: {@link https://aptos.dev/concepts/accounts#single-signer-authentication}
-   *
-   * @param args.publicKey PublicKey - public key of the account
-   * @returns The authentication key for the associated account
-   */
-  static authKey(args: { publicKey: PublicKey }): AuthenticationKey {
-    const { publicKey } = args;
-    return AuthenticationKey.fromPublicKey({ publicKey });
-  }
-
-  /**
-   * Sign the given message with the private key.
-   *
-   * TODO: Add sign transaction or specific types
-   *
-   * @param data in HexInput format
-   * @returns Signature
-   */
-  sign(data: HexInput): Signature {
-    return this.privateKey.sign(data);
-  }
-
-  /**
-   * Verify the given message and signature with the public key.
-   *
-   * @param args.message raw message data in HexInput format
-   * @param args.signature signed message Signature
-   * @returns
-   */
-  verifySignature(args: { message: HexInput; signature: Signature }): boolean {
-    const { message, signature } = args;
-    const rawMessage = Hex.fromHexInput(message).toUint8Array();
-    return this.publicKey.verifySignature({ message: rawMessage, signature });
-  }
-}

package/src/core/crypto/anyPublicKey.ts

@@ -1,92 +0,0 @@
-import { Serializer, Deserializer } from "../../bcs";
-import { AnyPublicKeyVariant, HexInput } from "../../types";
-import { AnySignature } from "./anySignature";
-import { PublicKey } from "./asymmetricCrypto";
-import { Ed25519PublicKey } from "./ed25519";
-import { Secp256k1PublicKey } from "./secp256k1";
-
-/**
- * Represents any public key supported by Aptos.
- *
- * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports
- * `Legacy` and `Unified` authentication keys.
- *
- * Any unified authentication key is represented in the SDK as `AnyPublicKey`.
- */
-export class AnyPublicKey extends PublicKey {
-  /**
-   * Reference to the inner public key
-   */
-  public readonly publicKey: PublicKey;
-
-  constructor(publicKey: PublicKey) {
-    super();
-    this.publicKey = publicKey;
-  }
-
-  /**
-   * Get the public key in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the public key
-   */
-  toUint8Array(): Uint8Array {
-    return this.publicKey.toUint8Array();
-  }
-
-  /**
-   * Get the public key as a hex string with the 0x prefix.
-   *
-   * @returns string representation of the public key
-   */
-  toString(): string {
-    return this.publicKey.toString();
-  }
-
-  /**
-   * Verifies a signed data with a public key
-   *
-   * @param args.message message
-   * @param args.signature The signature
-   * @returns true if the signature is valid
-   */
-  verifySignature(args: { message: HexInput; signature: AnySignature }): boolean {
-    const { message, signature } = args;
-    return this.publicKey.verifySignature({ message, signature });
-  }
-
-  serialize(serializer: Serializer): void {
-    if (this.publicKey instanceof Ed25519PublicKey) {
-      serializer.serializeU32AsUleb128(AnyPublicKeyVariant.Ed25519);
-      this.publicKey.serialize(serializer);
-    } else if (this.publicKey instanceof Secp256k1PublicKey) {
-      serializer.serializeU32AsUleb128(AnyPublicKeyVariant.Secp256k1);
-      this.publicKey.serialize(serializer);
-    } else {
-      throw new Error("Unknown public key type");
-    }
-  }
-
-  static deserialize(deserializer: Deserializer): AnyPublicKey {
-    const index = deserializer.deserializeUleb128AsU32();
-    switch (index) {
-      case AnyPublicKeyVariant.Ed25519:
-        return new AnyPublicKey(Ed25519PublicKey.load(deserializer));
-      case AnyPublicKeyVariant.Secp256k1:
-        return new AnyPublicKey(Secp256k1PublicKey.load(deserializer));
-      default:
-        throw new Error(`Unknown variant index for AnyPublicKey: ${index}`);
-    }
-  }
-
-  static isPublicKey(publicKey: PublicKey): publicKey is AnyPublicKey {
-    return publicKey instanceof AnyPublicKey;
-  }
-
-  isEd25519(): this is Ed25519PublicKey {
-    return this.publicKey instanceof Ed25519PublicKey;
-  }
-
-  isSecp256k1PublicKey(): this is Secp256k1PublicKey {
-    return this.publicKey instanceof Secp256k1PublicKey;
-  }
-}

package/src/core/crypto/anySignature.ts

@@ -1,56 +0,0 @@
-import { Serializer, Deserializer } from "../../bcs";
-import { AnySignatureVariant } from "../../types";
-import { Signature } from "./asymmetricCrypto";
-import { Ed25519Signature } from "./ed25519";
-import { Secp256k1Signature } from "./secp256k1";
-
-export class AnySignature extends Signature {
-  public readonly signature: Signature;
-
-  constructor(signature: Signature) {
-    super();
-    this.signature = signature;
-  }
-
-  /**
-   * Get the public key in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the public key
-   */
-  toUint8Array(): Uint8Array {
-    return this.signature.toUint8Array();
-  }
-
-  /**
-   * Get the public key as a hex string with the 0x prefix.
-   *
-   * @returns string representation of the public key
-   */
-  toString(): string {
-    return this.signature.toString();
-  }
-
-  serialize(serializer: Serializer): void {
-    if (this.signature instanceof Ed25519Signature) {
-      serializer.serializeU32AsUleb128(AnySignatureVariant.Ed25519);
-      this.signature.serialize(serializer);
-    } else if (this.signature instanceof Secp256k1Signature) {
-      serializer.serializeU32AsUleb128(AnySignatureVariant.Secp256k1);
-      this.signature.serialize(serializer);
-    } else {
-      throw new Error("Unknown signature type");
-    }
-  }
-
-  static deserialize(deserializer: Deserializer): AnySignature {
-    const index = deserializer.deserializeUleb128AsU32();
-    switch (index) {
-      case AnySignatureVariant.Ed25519:
-        return new AnySignature(Ed25519Signature.load(deserializer));
-      case AnySignatureVariant.Secp256k1:
-        return new AnySignature(Secp256k1Signature.load(deserializer));
-      default:
-        throw new Error(`Unknown variant index for AnySignature: ${index}`);
-    }
-  }
-}

package/src/core/crypto/asymmetricCrypto.ts

@@ -1,77 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-import { Serializable, Serializer } from "../../bcs";
-import { HexInput } from "../../types";
-
-/**
- * An abstract representation of a public key.  All Asymmetric key pairs will use this to
- * verify signatures and for authentication keys.
- */
-export abstract class PublicKey extends Serializable {
-  /**
-   * Verifies that the private key associated with this public key signed the message with the given signature.
-   * @param args.message The message that was signed
-   * @param args.signature The signature to verify
-   */
-  abstract verifySignature(args: { message: HexInput; signature: Signature }): boolean;
-
-  /**
-   * Get the raw public key bytes
-   */
-  abstract toUint8Array(): Uint8Array;
-
-  /**
-   * Get the public key as a hex string with a 0x prefix e.g. 0x123456...
-   */
-  abstract toString(): string;
-
-  abstract serialize(serializer: Serializer): void;
-}
-
-/**
- * An abstract representation of a private key.  This is used to sign transactions and
- * derive the public key associated.
- */
-export abstract class PrivateKey extends Serializable {
-  /**
-   * Sign a message with the key
-   * @param message The message to sign
-   */
-  abstract sign(message: HexInput): Signature;
-
-  /**
-   * Get the raw private key bytes
-   */
-  abstract toUint8Array(): Uint8Array;
-
-  /**
-   * Get the private key as a hex string with a 0x prefix e.g. 0x123456...
-   */
-  abstract toString(): string;
-
-  abstract serialize(serializer: Serializer): void;
-
-  /**
-   * Derives the public key associated with the private key
-   */
-  abstract publicKey(): PublicKey;
-}
-
-/**
- * An abstract representation of a signature.  This is the product of signing a
- * message and can be used with the PublicKey to verify the signature.
- */
-export abstract class Signature extends Serializable {
-  /**
-   * Get the raw signature bytes
-   */
-  abstract toUint8Array(): Uint8Array;
-
-  /**
-   * Get the signature as a hex string with a 0x prefix e.g. 0x123456...
-   */
-  abstract toString(): string;
-
-  abstract serialize(serializer: Serializer): void;
-}