@aptos-labs/ts-sdk 1.13.3-zeta.1 → 1.14.0

package/src/account/KeylessAccount.ts

@@ -1,299 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-import { JwtPayload, jwtDecode } from "jwt-decode";
-import { decode } from "base-64";
-import EventEmitter from "eventemitter3";
-import { HexInput, SigningScheme } from "../types";
-import { AccountAddress } from "../core/accountAddress";
-import {
-  AnyPublicKey,
-  AnySignature,
-  KeylessPublicKey,
-  KeylessSignature,
-  OpenIdSignature,
-  OpenIdSignatureOrZkProof,
-  Signature,
-  SignedGroth16Signature,
-  computeAddressSeed,
-  fromDerivationPath as fromDerivationPathInner,
-} from "../core/crypto";
-
-import { Account } from "./Account";
-import { EphemeralKeyPair } from "./EphemeralKeyPair";
-import { Hex } from "../core/hex";
-import { AccountAuthenticatorSingleKey } from "../transactions/authenticator/account";
-import { Deserializer, Serializer } from "../bcs";
-import { deriveTransactionType, generateSigningMessage } from "../transactions/transactionBuilder/signingMessage";
-import { AnyRawTransaction } from "../transactions/types";
-
-function base64UrlDecode(base64Url: string): string {
-  // Replace base64url-specific characters
-  const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
-
-  // Pad the string with '=' characters if needed
-  const paddedBase64 = base64 + "==".substring(0, (3 - (base64.length % 3)) % 3);
-
-  // Decode the base64 string using the base-64 library
-  const decodedString = decode(paddedBase64);
-
-  return decodedString;
-}
-
-export type ProofFetchSuccess = {
-  status: "Success";
-};
-
-export type ProofFetchFailure = {
-  status: "Failed";
-  error: string;
-};
-
-export type ProofFetchStatus = ProofFetchSuccess | ProofFetchFailure
-
-export type ProofFetchCallback = (status: ProofFetchStatus) => Promise<void>;
-
-export interface ProofFetchEvents {
-  proofFetchFinish: (status: ProofFetchStatus) => void;
-}
-
-export class KeylessAccount implements Account {
-  static readonly PEPPER_LENGTH: number = 31;
-
-  static readonly SLIP_0010_SEED: string = "32 bytes";
-
-  publicKey: KeylessPublicKey;
-
-  ephemeralKeyPair: EphemeralKeyPair;
-
-  uidKey: string;
-
-  uidVal: string;
-
-  aud: string;
-
-  pepper: Uint8Array;
-
-  accountAddress: AccountAddress;
-
-  proof: SignedGroth16Signature | undefined;
-
-  proofOrPromise: SignedGroth16Signature | Promise<SignedGroth16Signature>;
-
-  signingScheme: SigningScheme;
-
-  jwt: string;
-
-  emitter: EventEmitter<ProofFetchEvents>;
-
-  constructor(args: {
-    address?: AccountAddress;
-    ephemeralKeyPair: EphemeralKeyPair;
-    iss: string;
-    uidKey: string;
-    uidVal: string;
-    aud: string;
-    pepper: HexInput;
-    proofOrFetcher: SignedGroth16Signature | Promise<SignedGroth16Signature>;
-    proofFetchCallback?: ProofFetchCallback
-    jwt: string;
-  }) {
-    const { address, ephemeralKeyPair, iss, uidKey, uidVal, aud, pepper, proofOrFetcher, proofFetchCallback, jwt } = args;
-    this.ephemeralKeyPair = ephemeralKeyPair;
-    const addressSeed = computeAddressSeed(args);
-    this.publicKey = new KeylessPublicKey(iss, addressSeed);
-    this.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();
-    this.uidKey = uidKey;
-    this.uidVal = uidVal;
-    this.aud = aud;
-    this.jwt = jwt;
-    this.emitter = new EventEmitter<ProofFetchEvents>();
-    this.proofOrPromise = proofOrFetcher;
-    if (proofOrFetcher instanceof SignedGroth16Signature) {
-      this.proof = proofOrFetcher;
-    } else {
-      if (proofFetchCallback === undefined) {
-        throw new Error("Must provide callback")
-      }
-      this.emitter.on("proofFetchFinish", async (status) => {
-        await proofFetchCallback(status);
-        this.emitter.removeAllListeners();
-      });
-      this.init(proofOrFetcher);
-    }
-    
-
-    this.signingScheme = SigningScheme.SingleKey;
-    const pepperBytes = Hex.fromHexInput(pepper).toUint8Array();
-    if (pepperBytes.length !== KeylessAccount.PEPPER_LENGTH) {
-      throw new Error(`Pepper length in bytes should be ${KeylessAccount.PEPPER_LENGTH}`);
-    }
-    this.pepper = pepperBytes;
-  }
-
-  async init(promise: Promise<SignedGroth16Signature>) {
-    try {
-      this.proof = await promise;
-      this.emitter.emit("proofFetchFinish", {status: "Success"});
-    } catch (error) {
-      if (error instanceof Error) {
-        this.emitter.emit("proofFetchFinish", {status: "Failed", error: error.toString()});
-      } else {
-        this.emitter.emit("proofFetchFinish", {status: "Failed", error: "Unknown"});
-      }
-    }
-  }
-
-  serialize(serializer: Serializer): void {
-    serializer.serializeStr(this.jwt);
-    serializer.serializeStr(this.uidKey);
-    serializer.serializeFixedBytes(this.pepper);
-    this.ephemeralKeyPair.serialize(serializer);
-    if (this.proof === undefined) {
-      throw new Error("Connot serialize - proof undefined")
-    }
-    this.proof.serialize(serializer);
-  }
-
-  static deserialize(deserializer: Deserializer): KeylessAccount {
-    const jwt = deserializer.deserializeStr();
-    const uidKey = deserializer.deserializeStr();
-    const pepper = deserializer.deserializeFixedBytes(31);
-    const ephemeralKeyPair = EphemeralKeyPair.deserialize(deserializer);
-    const proof = SignedGroth16Signature.deserialize(deserializer);
-    return KeylessAccount.fromJWTAndProof({
-      proof,
-      pepper,
-      uidKey,
-      jwt,
-      ephemeralKeyPair,
-    });
-  }
-
-  isExpired(): boolean {
-    return this.ephemeralKeyPair.isExpired();
-  }
-
-  bcsToBytes(): Uint8Array {
-    const serializer = new Serializer();
-    this.serialize(serializer);
-    return serializer.toUint8Array();
-  }
-
-  bcsToHex(): Hex {
-    const bcsBytes = this.bcsToBytes();
-    return Hex.fromHexInput(bcsBytes);
-  }
-
-  signWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticatorSingleKey {
-    const raw = deriveTransactionType(transaction);
-    const signature = new AnySignature(this.sign(raw.bcsToBytes()));
-    const publicKey = new AnyPublicKey(this.publicKey);
-    return new AccountAuthenticatorSingleKey(publicKey, signature);
-  }
-
-  async waitForProofFetch() {
-    if (this.proofOrPromise instanceof Promise) {
-      await this.proofOrPromise;
-    }
-  }
-
-  sign(data: HexInput): Signature {
-    const { expiryDateSecs } = this.ephemeralKeyPair;
-    const currentTimeInSeconds = Math.floor(new Date().getTime() / 1000);
-    if (expiryDateSecs < currentTimeInSeconds) {
-      throw new Error("Ephemeral key pair is expired.");
-    }
-    if (this.proof === undefined) {
-      throw new Error("Proof not found");
-    }
-    const jwtHeader = this.jwt.split(".")[0];
-    const ephemeralPublicKey = this.ephemeralKeyPair.getPublicKey();
-
-    const serializer = new Serializer();
-    serializer.serializeFixedBytes(Hex.fromHexInput(data).toUint8Array());
-    serializer.serializeOption(this.proof.proof);
-    const signMess = generateSigningMessage(serializer.toUint8Array(), "APTOS::TransactionAndProof");
-
-    const ephemeralSignature = this.ephemeralKeyPair.sign(signMess);
-
-    return new KeylessSignature({
-      jwtHeader: base64UrlDecode(jwtHeader),
-      openIdSignatureOrZkProof: new OpenIdSignatureOrZkProof(this.proof),
-      expiryDateSecs,
-      ephemeralPublicKey,
-      ephemeralSignature,
-    });
-  }
-
-  signTransaction(transaction: AnyRawTransaction): Signature {
-    const raw = deriveTransactionType(transaction);
-    return this.sign(raw.bcsToBytes());
-  }
-
-  signWithOpenIdSignature(data: HexInput): Signature {
-    const [jwtHeader, jwtPayload, jwtSignature] = this.jwt.split(".");
-    const openIdSig = new OpenIdSignature({
-      jwtSignature,
-      jwtPayloadJson: jwtPayload,
-      uidKey: this.uidKey,
-      epkBlinder: this.ephemeralKeyPair.blinder,
-      pepper: this.pepper,
-    });
-
-    const { expiryDateSecs } = this.ephemeralKeyPair;
-    const ephemeralPublicKey = this.ephemeralKeyPair.getPublicKey();
-    const ephemeralSignature = this.ephemeralKeyPair.sign(data);
-    return new KeylessSignature({
-      jwtHeader,
-      openIdSignatureOrZkProof: new OpenIdSignatureOrZkProof(openIdSig),
-      expiryDateSecs,
-      ephemeralPublicKey,
-      ephemeralSignature,
-    });
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
-  verifySignature(args: { message: HexInput; signature: Signature }): boolean {
-    return true;
-  }
-
-  static fromBytes(bytes: Uint8Array): KeylessAccount {
-    return KeylessAccount.deserialize(new Deserializer(bytes));
-  }
-
-  static fromJWTAndProof(args: {
-    proof: SignedGroth16Signature | Promise<SignedGroth16Signature>;
-    jwt: string;
-    ephemeralKeyPair: EphemeralKeyPair;
-    pepper: HexInput;
-    uidKey?: string;
-    proofFetchCallback?: ProofFetchCallback;
-  }): KeylessAccount {
-    const { proof, jwt, ephemeralKeyPair, pepper, proofFetchCallback } = args;
-    const uidKey = args.uidKey ?? "sub";
-
-    const jwtPayload = jwtDecode<JwtPayload & { [key: string]: string }>(jwt);
-    const iss = jwtPayload.iss!;
-    if (typeof jwtPayload.aud !== "string") {
-      throw new Error("aud was not found or an array of values");
-    }
-    const aud = jwtPayload.aud!;
-    const uidVal = jwtPayload[uidKey];
-    return new KeylessAccount({
-      proofOrFetcher: proof,
-      ephemeralKeyPair,
-      iss,
-      uidKey,
-      uidVal,
-      aud,
-      pepper,
-      jwt,
-      proofFetchCallback,
-    });
-  }
-
-  static fromDerivationPath(path: string, seed: Uint8Array): Uint8Array {
-    return fromDerivationPathInner(path, KeylessAccount.SLIP_0010_SEED, seed);
-  }
-}

package/src/account/MultiKeyAccount.ts

@@ -1,119 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-import { Account } from "./Account";
-import { MultiKey, MultiSignature, PublicKey, Signature } from "../core/crypto";
-import { AccountAddress } from "../core/accountAddress";
-import { HexInput, SigningScheme } from "../types";
-import { AccountAuthenticatorMultiKey } from "../transactions/authenticator/account";
-import { AnyRawTransaction } from "../transactions/types";
-import { KeylessAccount } from "./KeylessAccount";
-
-export class MultiKeyAccount implements Account {
-  /**
-   * Public key associated with the account
-   */
-  readonly publicKey: MultiKey;
-
-  /**
-   * Account address associated with the account
-   */
-  readonly accountAddress: AccountAddress;
-
-  /**
-   * Signing scheme used to sign transactions
-   */
-  readonly signingScheme: SigningScheme;
-
-  signers: Account[];
-
-  signaturesBitmap: Uint8Array;
-
-  /**
-   * 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
-   */
-  constructor(args: { multiKey: MultiKey; signers: Account[] }) {
-    const { multiKey, signers } = args;
-
-    this.publicKey = multiKey;
-    this.signers = signers;
-    this.signingScheme = SigningScheme.MultiKey;
-
-    this.accountAddress = this.publicKey.authKey().derivedAddress();
-
-    const bits: number[] = [];
-    for (const signer of signers) {
-      bits.push(this.publicKey.getIndex(signer.publicKey));
-    }
-    this.signaturesBitmap = this.publicKey.createBitmap({ bits });
-  }
-
-  static fromPublicKeysAndSigners(args: {
-    publicKeys: PublicKey[];
-    signaturesRequired: number;
-    signers: Account[];
-  }): MultiKeyAccount {
-    const { publicKeys, signaturesRequired, signers } = args;
-    const multiKey = new MultiKey({ publicKeys, signaturesRequired });
-    return new MultiKeyAccount({ multiKey, signers });
-  }
-
-  static isMultiKeySigner(account: Account): account is MultiKeyAccount {
-    return account instanceof MultiKeyAccount;
-  }
-
-  signWithAuthenticator(transaction: AnyRawTransaction) {
-    return new AccountAuthenticatorMultiKey(this.publicKey, this.signTransaction(transaction));
-  }
-
-  async waitForProofFetch() {
-    const keylessSigners = this.signers.filter((signer) => signer instanceof KeylessAccount) as KeylessAccount[];
-    await Promise.all(keylessSigners.filter((signer) => signer.proof instanceof Promise).map((signer) => signer.proof));
-  }
-
-  /**
-   * 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): MultiSignature {
-    const signatures = [];
-    for (const signer of this.signers) {
-      signatures.push(signer.sign(data));
-    }
-    return new MultiSignature({ signatures, bitmap: this.signaturesBitmap });
-  }
-
-  signTransaction(transaction: AnyRawTransaction) {
-    const signatures = [];
-    for (const signer of this.signers) {
-      signatures.push(signer.signTransaction(transaction));
-    }
-    return new MultiSignature({ signatures, bitmap: this.signaturesBitmap });
-  }
-
-  /**
-   * 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
-   */
-  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
-  verifySignature(args: { message: HexInput; signature: Signature }): boolean {
-    return true;
-  }
-}

package/src/account/index.ts

@@ -1,6 +0,0 @@
-export * from "./Ed25519Account";
-export * from "./Account";
-export * from "./SingleKeyAccount";
-export * from "./KeylessAccount";
-export * from "./EphemeralKeyPair";
-export * from "./MultiKeyAccount";

package/src/api/keyless.ts

@@ -1,35 +0,0 @@
-// Copyright © Aptos Foundation
-// SPDX-License-Identifier: Apache-2.0
-
-import { EphemeralKeyPair, KeylessAccount, ProofFetchCallback } from "../account";
-import { deriveKeylessAccount, getPepper } from "../internal/keyless";
-import { HexInput } from "../types";
-import { AptosConfig } from "./aptosConfig";
-
-/**
- * A class to query all `OIDB` related queries on Aptos.
- */
-export class Keyless {
-  constructor(readonly config: AptosConfig) {}
-
-  /**
-   * TODO
-   *
-   * @param args.jwt jwt token
-   * @returns The pepper
-   */
-  async getPepper(args: { jwt: string; ephemeralKeyPair: EphemeralKeyPair }): Promise<Uint8Array> {
-    return getPepper({ aptosConfig: this.config, ...args });
-  }
-
-  async deriveKeylessAccount(args: {
-    jwt: string;
-    ephemeralKeyPair: EphemeralKeyPair;
-    uidKey?: string;
-    pepper?: HexInput;
-    extraFieldKey?: string;
-    proofFetchCallback?: ProofFetchCallback;
-  }): Promise<KeylessAccount> {
-    return deriveKeylessAccount({ aptosConfig: this.config, ...args });
-  }
-}

package/src/core/crypto/ephemeral.ts

@@ -1,149 +0,0 @@
-import { Serializer, Deserializer } from "../../bcs";
-import { EphemeralPublicKeyVariant, EphemeralSignatureVariant, HexInput } from "../../types";
-import { PublicKey } from "./publicKey";
-import { Signature } from "./signature";
-import { Ed25519PublicKey, Ed25519Signature } from "./ed25519";
-import { Hex } from "../hex";
-
-/**
- * Represents ephemeral keys and signatures for Aptos Keyless accounts.
- *
- * TODO
- */
-export class EphemeralPublicKey extends PublicKey {
-  /**
-   * Reference to the inner public key
-   */
-  public readonly publicKey: PublicKey;
-
-  public readonly variant: EphemeralPublicKeyVariant;
-
-  constructor(publicKey: PublicKey) {
-    super();
-    const publicKeyType = publicKey.constructor.name;
-    switch (publicKeyType) {
-      case Ed25519PublicKey.name:
-        this.publicKey = publicKey;
-        this.variant = EphemeralPublicKeyVariant.Ed25519;
-        break;
-      default:
-        throw new Error(`Unsupported key for EphemeralPublicKey - ${publicKeyType}`);
-    }
-  }
-
-  /**
-   * Get the public key in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the public key
-   */
-  toUint8Array(): Uint8Array {
-    return this.bcsToBytes();
-  }
-
-  /**
-   * Get the public key as a hex string with the 0x prefix.
-   *
-   * @returns string representation of the public key
-   */
-  toString(): string {
-    return this.bcsToHex().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: EphemeralSignature }): boolean {
-    const { message, signature } = args;
-    return this.publicKey.verifySignature({ message, signature });
-  }
-
-  serialize(serializer: Serializer): void {
-    if (this.publicKey instanceof Ed25519PublicKey) {
-      serializer.serializeU32AsUleb128(EphemeralPublicKeyVariant.Ed25519);
-      this.publicKey.serialize(serializer);
-    } else {
-      throw new Error("Unknown public key type");
-    }
-  }
-
-  static deserialize(deserializer: Deserializer): EphemeralPublicKey {
-    const index = deserializer.deserializeUleb128AsU32();
-    switch (index) {
-      case EphemeralPublicKeyVariant.Ed25519:
-        return new EphemeralPublicKey(Ed25519PublicKey.deserialize(deserializer));
-      default:
-        throw new Error(`Unknown variant index for EphemeralPublicKey: ${index}`);
-    }
-  }
-
-  static isPublicKey(publicKey: PublicKey): publicKey is EphemeralPublicKey {
-    return publicKey instanceof EphemeralPublicKey;
-  }
-
-  isEd25519(): this is Ed25519PublicKey {
-    return this.publicKey instanceof Ed25519PublicKey;
-  }
-}
-
-export class EphemeralSignature extends Signature {
-  public readonly signature: Signature;
-
-  constructor(signature: Signature) {
-    super();
-    const signatureType = signature.constructor.name;
-    switch (signatureType) {
-      case Ed25519Signature.name:
-        this.signature = signature;
-        break;
-      default:
-        throw new Error(`Unsupported signature for EphemeralSignature - ${signatureType}`);
-    }
-  }
-
-  /**
-   * 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();
-  }
-
-  static fromHex(hexInput: HexInput): EphemeralSignature {
-    const data = Hex.fromHexInput(hexInput);
-    const deserializer = new Deserializer(data.toUint8Array());
-    return EphemeralSignature.deserialize(deserializer);
-  }
-
-  serialize(serializer: Serializer): void {
-    if (this.signature instanceof Ed25519Signature) {
-      serializer.serializeU32AsUleb128(EphemeralSignatureVariant.Ed25519);
-      this.signature.serialize(serializer);
-    } else {
-      throw new Error("Unknown signature type");
-    }
-  }
-
-  static deserialize(deserializer: Deserializer): EphemeralSignature {
-    const index = deserializer.deserializeUleb128AsU32();
-    switch (index) {
-      case EphemeralSignatureVariant.Ed25519:
-        return new EphemeralSignature(Ed25519Signature.deserialize(deserializer));
-      default:
-        throw new Error(`Unknown variant index for EphemeralSignature: ${index}`);
-    }
-  }
-}