@aptos-labs/ts-sdk 1.14.0-zeta.2 → 1.14.0-zeta.4

package/dist/esm/chunk-JV3GSIJW.mjs

@@ -1,268 +0,0 @@
-import {
-  EphemeralKeyPair
-} from "./chunk-LI2QV6RU.mjs";
-import {
-  deriveTransactionType,
-  generateSigningMessageForSerializable
-} from "./chunk-VJP2VWMF.mjs";
-import {
-  AccountAuthenticatorSingleKey
-} from "./chunk-IC56GQFJ.mjs";
-import {
-  AnyPublicKey,
-  AnySignature
-} from "./chunk-TLNHRJB2.mjs";
-import {
-  EphemeralCertificate,
-  KeylessPublicKey,
-  KeylessSignature,
-  ZeroKnowledgeSig
-} from "./chunk-4OYYOYSO.mjs";
-import {
-  AccountAddress
-} from "./chunk-CMNJG4NN.mjs";
-import {
-  Deserializer
-} from "./chunk-7JRMOHBP.mjs";
-import {
-  Serializable
-} from "./chunk-FQQW55X7.mjs";
-import {
-  Hex
-} from "./chunk-YV7M4CFP.mjs";
-
-// src/account/KeylessAccount.ts
-import { jwtDecode } from "jwt-decode";
-import { JwksClient } from "jwks-rsa";
-import { decode } from "base-64";
-import EventEmitter from "eventemitter3";
-var IssuerToJwkEndpoint = {
-  "https://accounts.google.com": "https://www.googleapis.com/oauth2/v3/certs"
-};
-var _KeylessAccount = class _KeylessAccount extends Serializable {
-  constructor(args) {
-    super();
-    const { address, ephemeralKeyPair, uidKey, uidVal, aud, pepper, proofOrFetcher, proofFetchCallback, jwt } = args;
-    this.ephemeralKeyPair = ephemeralKeyPair;
-    this.publicKey = KeylessPublicKey.create(args);
-    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();
-    this.proofOrPromise = proofOrFetcher;
-    if (proofOrFetcher instanceof ZeroKnowledgeSig) {
-      this.proof = proofOrFetcher;
-    } else {
-      if (proofFetchCallback === void 0) {
-        throw new Error("Must provide callback for async proof fetch");
-      }
-      this.emitter.on("proofFetchFinish", async (status) => {
-        await proofFetchCallback(status);
-        this.emitter.removeAllListeners();
-      });
-      this.init(proofOrFetcher);
-    }
-    this.signingScheme = 2 /* 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;
-    this.isJwtValid = true;
-  }
-  /**
-   * This initializes the asyncronous proof fetch
-   * @return
-   */
-  async init(promise) {
-    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.serializeStr(this.jwt);
-    serializer.serializeStr(this.uidKey);
-    serializer.serializeFixedBytes(this.pepper);
-    this.ephemeralKeyPair.serialize(serializer);
-    if (this.proof === void 0) {
-      throw new Error("Connot serialize - proof undefined");
-    }
-    this.proof.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    const jwt = deserializer.deserializeStr();
-    const uidKey = deserializer.deserializeStr();
-    const pepper = deserializer.deserializeFixedBytes(31);
-    const ephemeralKeyPair = EphemeralKeyPair.deserialize(deserializer);
-    const proof = ZeroKnowledgeSig.deserialize(deserializer);
-    return _KeylessAccount.fromJWTAndProof({
-      proof,
-      pepper,
-      uidKey,
-      jwt,
-      ephemeralKeyPair
-    });
-  }
-  /**
-   * Checks if the proof is expired.  If so the account must be rederived with a new EphemeralKeyPair
-   * and JWT token.
-   * @return boolean
-   */
-  isExpired() {
-    return this.ephemeralKeyPair.isExpired();
-  }
-  /**
-   * Checks if the the JWK used to verify the token still exists on the issuer's JWK uri.
-   * Caches the result.
-   * @return boolean
-   */
-  async checkJwkValidity() {
-    if (!this.isJwtValid) {
-      return false;
-    }
-    const jwtHeader = jwtDecode(this.jwt, { header: true });
-    const client = new JwksClient({
-      jwksUri: IssuerToJwkEndpoint[this.publicKey.iss]
-    });
-    try {
-      await client.getSigningKey(jwtHeader.kid);
-      return true;
-    } catch (error) {
-      this.isJwtValid = false;
-      return false;
-    }
-  }
-  /**
-   * Sign a message using Keyless.
-   * @param message the message to sign, as binary input
-   * @return the AccountAuthenticator containing the signature, together with the account's public key
-   */
-  signWithAuthenticator(message) {
-    const signature = new AnySignature(this.sign(message));
-    const publicKey = new AnyPublicKey(this.publicKey);
-    return new AccountAuthenticatorSingleKey(publicKey, signature);
-  }
-  /**
-   * Sign a transaction using Keyless.
-   * @param transaction the raw transaction
-   * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
-   */
-  signTransactionWithAuthenticator(transaction) {
-    const signature = new AnySignature(this.signTransaction(transaction));
-    const publicKey = new AnyPublicKey(this.publicKey);
-    return new AccountAuthenticatorSingleKey(publicKey, signature);
-  }
-  /**
-   * Waits for asyncronous proof fetching to finish.
-   * @return
-   */
-  async waitForProofFetch() {
-    if (this.proofOrPromise instanceof Promise) {
-      await this.proofOrPromise;
-    }
-  }
-  /**
-   * Sign the given message using Keyless.
-   * @param message in HexInput format
-   * @returns Signature
-   */
-  sign(data) {
-    const { expiryDateSecs } = this.ephemeralKeyPair;
-    if (this.isExpired()) {
-      throw new Error("Ephemeral key pair is expired.");
-    }
-    if (this.proof === void 0) {
-      throw new Error("Proof not found");
-    }
-    if (!this.isJwtValid) {
-      throw new Error("The proof has expired. Please refetch proof");
-    }
-    const ephemeralPublicKey = this.ephemeralKeyPair.getPublicKey();
-    const ephemeralSignature = this.ephemeralKeyPair.sign(data);
-    return new KeylessSignature({
-      jwtHeader: base64UrlDecode(this.jwt.split(".")[0]),
-      ephemeralCertificate: new EphemeralCertificate(this.proof, 0 /* ZkProof */),
-      expiryDateSecs,
-      ephemeralPublicKey,
-      ephemeralSignature
-    });
-  }
-  /**
-   * Sign the given transaction with Keyless.
-   * Signs the transaction and proof to guard against proof malleability.
-   * @param transaction the transaction to be signed
-   * @returns KeylessSignature
-   */
-  signTransaction(transaction) {
-    if (this.proof === void 0) {
-      throw new Error("Proof not found");
-    }
-    const raw = deriveTransactionType(transaction);
-    const txnAndProof = new TransactionAndProof(raw, this.proof.proof);
-    const signMess = generateSigningMessageForSerializable(txnAndProof);
-    return this.sign(signMess);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
-  verifySignature(args) {
-    throw new Error("Not implemented");
-  }
-  static fromBytes(bytes) {
-    return _KeylessAccount.deserialize(new Deserializer(bytes));
-  }
-  static fromJWTAndProof(args) {
-    const { proof, jwt, ephemeralKeyPair, pepper, proofFetchCallback } = args;
-    const uidKey = args.uidKey ?? "sub";
-    const jwtPayload = jwtDecode(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
-    });
-  }
-};
-_KeylessAccount.PEPPER_LENGTH = 31;
-var KeylessAccount = _KeylessAccount;
-var TransactionAndProof = class extends Serializable {
-  constructor(transaction, proof) {
-    super();
-    this.transaction = transaction;
-    this.proof = proof;
-  }
-  serialize(serializer) {
-    serializer.serializeFixedBytes(this.transaction.bcsToBytes());
-    serializer.serializeOption(this.proof);
-  }
-};
-function base64UrlDecode(base64Url) {
-  const base64 = base64Url.replace(/-/g, "+").replace(/_/g, "/");
-  const paddedBase64 = base64 + "==".substring(0, (3 - base64.length % 3) % 3);
-  const decodedString = decode(paddedBase64);
-  return decodedString;
-}
-
-export {
-  IssuerToJwkEndpoint,
-  KeylessAccount
-};
-//# sourceMappingURL=chunk-JV3GSIJW.mjs.map

package/dist/esm/chunk-KK2BSALW.mjs

@@ -1,32 +0,0 @@
-import {
-  Serializable
-} from "./chunk-FQQW55X7.mjs";
-import {
-  Hex
-} from "./chunk-YV7M4CFP.mjs";
-
-// src/bcs/serializable/fixedBytes.ts
-var FixedBytes = class _FixedBytes extends Serializable {
-  constructor(value) {
-    super();
-    this.value = Hex.fromHexInput(value).toUint8Array();
-  }
-  serialize(serializer) {
-    serializer.serializeFixedBytes(this.value);
-  }
-  serializeForEntryFunction(serializer) {
-    serializer.serialize(this);
-  }
-  serializeForScriptFunction(serializer) {
-    serializer.serialize(this);
-  }
-  static deserialize(deserializer, length) {
-    const bytes = deserializer.deserializeFixedBytes(length);
-    return new _FixedBytes(bytes);
-  }
-};
-
-export {
-  FixedBytes
-};
-//# sourceMappingURL=chunk-KK2BSALW.mjs.map

package/dist/esm/chunk-KMXSRHJ6.mjs

@@ -1,93 +0,0 @@
-import {
-  generateSigningMessageForTransaction
-} from "./chunk-VJP2VWMF.mjs";
-import {
-  AccountAuthenticatorEd25519
-} from "./chunk-IC56GQFJ.mjs";
-import {
-  Ed25519PrivateKey
-} from "./chunk-RX4VG2AT.mjs";
-import {
-  AccountAddress
-} from "./chunk-CMNJG4NN.mjs";
-
-// src/account/Ed25519Account.ts
-var Ed25519Account = class _Ed25519Account {
-  // region Constructors
-  constructor(args) {
-    this.signingScheme = 0 /* Ed25519 */;
-    const { privateKey, address } = args;
-    this.privateKey = privateKey;
-    this.publicKey = privateKey.publicKey();
-    this.accountAddress = address ? AccountAddress.from(address) : this.publicKey.authKey().derivedAddress();
-  }
-  /**
-   * Derives a signer from a randomly generated private key
-   */
-  static generate() {
-    const privateKey = Ed25519PrivateKey.generate();
-    return new _Ed25519Account({ privateKey });
-  }
-  /**
-   * Derives an account with bip44 path and mnemonics
-   *
-   * @param args.path the BIP44 derive hardened path e.g. m/44'/637'/0'/0'/0'
-   * Detailed description: {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
-   * @param args.mnemonic the mnemonic seed phrase of the account
-   */
-  static fromDerivationPath(args) {
-    const { path, mnemonic } = args;
-    const privateKey = Ed25519PrivateKey.fromDerivationPath(path, mnemonic);
-    return new _Ed25519Account({ privateKey });
-  }
-  // endregion
-  // region Account
-  /**
-   * 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) {
-    return this.publicKey.verifySignature(args);
-  }
-  /**
-   * Sign a message using the account's Ed25519 private key.
-   * @param message the signing message, as binary input
-   * @return the AccountAuthenticator containing the signature, together with the account's public key
-   */
-  signWithAuthenticator(message) {
-    return new AccountAuthenticatorEd25519(this.publicKey, this.privateKey.sign(message));
-  }
-  /**
-   * Sign a transaction using the account's Ed25519 private key.
-   * @param transaction the raw transaction
-   * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
-   */
-  signTransactionWithAuthenticator(transaction) {
-    return new AccountAuthenticatorEd25519(this.publicKey, this.signTransaction(transaction));
-  }
-  /**
-   * Sign the given message using the account's Ed25519 private key.
-   * @param message in HexInput format
-   * @returns Signature
-   */
-  sign(message) {
-    return this.privateKey.sign(message);
-  }
-  /**
-   * Sign the given transaction using the available signing capabilities.
-   * @param transaction the transaction to be signed
-   * @returns Signature
-   */
-  signTransaction(transaction) {
-    return this.sign(generateSigningMessageForTransaction(transaction));
-  }
-  // endregion
-};
-
-export {
-  Ed25519Account
-};
-//# sourceMappingURL=chunk-KMXSRHJ6.mjs.map

package/dist/esm/chunk-KVSQ57HU.mjs

@@ -1,45 +0,0 @@
-import {
-  waitForTransaction
-} from "./chunk-TBHU6ZW6.mjs";
-import {
-  postAptosFaucet
-} from "./chunk-NXFO2W4G.mjs";
-import {
-  DEFAULT_TXN_TIMEOUT_SEC
-} from "./chunk-NFJCQRVK.mjs";
-import {
-  AccountAddress
-} from "./chunk-CMNJG4NN.mjs";
-
-// src/internal/faucet.ts
-async function fundAccount(args) {
-  const { aptosConfig, accountAddress, amount, options } = args;
-  const timeout = options?.timeoutSecs || DEFAULT_TXN_TIMEOUT_SEC;
-  const { data } = await postAptosFaucet({
-    aptosConfig,
-    path: "fund",
-    body: {
-      address: AccountAddress.from(accountAddress).toString(),
-      amount
-    },
-    originMethod: "fundAccount"
-  });
-  const txnHash = data.txn_hashes[0];
-  const res = await waitForTransaction({
-    aptosConfig,
-    transactionHash: txnHash,
-    options: {
-      timeoutSecs: timeout,
-      checkSuccess: options?.checkSuccess
-    }
-  });
-  if (res.type === "user_transaction" /* User */) {
-    return res;
-  }
-  throw new Error(`Unexpected transaction received for fund account: ${res.type}`);
-}
-
-export {
-  fundAccount
-};
-//# sourceMappingURL=chunk-KVSQ57HU.mjs.map

package/dist/esm/chunk-LI2QV6RU.mjs

@@ -1,129 +0,0 @@
-import {
-  EPK_HORIZON_SECS
-} from "./chunk-4OYYOYSO.mjs";
-import {
-  bytesToBigIntLE,
-  padAndPackBytesWithLen,
-  poseidonHash
-} from "./chunk-76TSTAU4.mjs";
-import {
-  EphemeralPublicKey,
-  EphemeralSignature
-} from "./chunk-B5S6DDUD.mjs";
-import {
-  Ed25519PrivateKey
-} from "./chunk-RX4VG2AT.mjs";
-import {
-  Deserializer
-} from "./chunk-7JRMOHBP.mjs";
-import {
-  Serializable
-} from "./chunk-FQQW55X7.mjs";
-import {
-  Hex
-} from "./chunk-YV7M4CFP.mjs";
-
-// src/account/EphemeralKeyPair.ts
-import { randomBytes } from "@noble/hashes/utils";
-var _EphemeralKeyPair = class _EphemeralKeyPair extends Serializable {
-  constructor(args) {
-    super();
-    const { privateKey, expiryDateSecs, blinder } = args;
-    this.privateKey = privateKey;
-    this.publicKey = new EphemeralPublicKey(privateKey.publicKey());
-    this.expiryDateSecs = expiryDateSecs || BigInt(floorToWholeHour(currentTimeInSeconds() + EPK_HORIZON_SECS));
-    this.blinder = blinder !== void 0 ? Hex.fromHexInput(blinder).toUint8Array() : generateBlinder();
-    this.nonce = this.generateNonce();
-  }
-  /**
-   * Returns the public key of the key pair.
-   * @return EphemeralPublicKey
-   */
-  getPublicKey() {
-    return this.publicKey;
-  }
-  /**
-   * Returns the public key of the key pair.
-   * @return boolean
-   */
-  isExpired() {
-    const currentTimeSecs = Math.floor(Date.now() / 1e3);
-    return currentTimeSecs > this.expiryDateSecs;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(this.publicKey.variant);
-    serializer.serializeBytes(this.privateKey.toUint8Array());
-    serializer.serializeU64(this.expiryDateSecs);
-    serializer.serializeFixedBytes(this.blinder);
-  }
-  static deserialize(deserializer) {
-    const variantIndex = deserializer.deserializeUleb128AsU32();
-    let privateKey;
-    switch (variantIndex) {
-      case 0 /* Ed25519 */:
-        privateKey = Ed25519PrivateKey.deserialize(deserializer);
-        break;
-      default:
-        throw new Error(`Unknown variant index for EphemeralPublicKey: ${variantIndex}`);
-    }
-    const expiryDateSecs = deserializer.deserializeU64();
-    const blinder = deserializer.deserializeFixedBytes(31);
-    return new _EphemeralKeyPair({ privateKey, expiryDateSecs, blinder });
-  }
-  static fromBytes(bytes) {
-    return _EphemeralKeyPair.deserialize(new Deserializer(bytes));
-  }
-  /**
-   * Returns the public key of the key pair.
-   * @param scheme the type of keypair to use for the EphemeralKeyPair.  Only Ed25519 supported for now.
-   * @return boolean
-   */
-  static generate(args) {
-    let privateKey;
-    switch (args?.scheme) {
-      case 0 /* Ed25519 */:
-      default:
-        privateKey = Ed25519PrivateKey.generate();
-    }
-    return new _EphemeralKeyPair({ privateKey });
-  }
-  generateNonce() {
-    const fields = padAndPackBytesWithLen(this.publicKey.bcsToBytes(), 93);
-    fields.push(BigInt(this.expiryDateSecs));
-    fields.push(bytesToBigIntLE(this.blinder));
-    const nonceHash = poseidonHash(fields);
-    return nonceHash.toString();
-  }
-  /**
-   * Sign the given message with the private key.
-   *
-   * @param data in HexInput format
-   * @returns EphemeralSignature
-   */
-  sign(data) {
-    if (this.isExpired()) {
-      throw new Error("EphemeralKeyPair has expired");
-    }
-    return new EphemeralSignature(this.privateKey.sign(data));
-  }
-};
-_EphemeralKeyPair.BLINDER_LENGTH = 31;
-var EphemeralKeyPair = _EphemeralKeyPair;
-function generateBlinder() {
-  return randomBytes(EphemeralKeyPair.BLINDER_LENGTH);
-}
-function currentTimeInSeconds() {
-  return Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3);
-}
-function floorToWholeHour(timestampInSeconds) {
-  const date = new Date(timestampInSeconds * 1e3);
-  date.setMinutes(0);
-  date.setSeconds(0);
-  date.setMilliseconds(0);
-  return Math.floor(date.getTime() / 1e3);
-}
-
-export {
-  EphemeralKeyPair
-};
-//# sourceMappingURL=chunk-LI2QV6RU.mjs.map

package/dist/esm/chunk-LLLQJWRZ.mjs

@@ -1,35 +0,0 @@
-import {
-  transferCoinTransaction
-} from "./chunk-NW45SCPY.mjs";
-
-// src/api/coin.ts
-var Coin = class {
-  constructor(config) {
-    this.config = config;
-  }
-  /**
-   * Generate a transfer coin transaction that can be simulated and/or signed and submitted
-   *
-   * @example
-   * const transferCoinTransaction = await aptos.transferCoinTransaction({
-   * sender: "0x123",
-   * recipient:"0x456",
-   * amount: 10,
-   * })
-   *
-   * @param args.sender The sender account
-   * @param args.recipient The recipient address
-   * @param args.amount The amount to transfer
-   * @param args.coinType optional. The coin struct type to transfer. Defaults to 0x1::aptos_coin::AptosCoin
-   *
-   * @returns SimpleTransaction
-   */
-  async transferCoinTransaction(args) {
-    return transferCoinTransaction({ aptosConfig: this.config, ...args });
-  }
-};
-
-export {
-  Coin
-};
-//# sourceMappingURL=chunk-LLLQJWRZ.mjs.map

package/dist/esm/chunk-LYK4TQZO.mjs

@@ -1,70 +0,0 @@
-import {
-  aptosRequest
-} from "./chunk-VKJQORON.mjs";
-
-// src/client/get.ts
-async function get(options) {
-  const { aptosConfig, overrides, params, contentType, acceptType, path, originMethod, type } = options;
-  const url = aptosConfig.getRequestUrl(type);
-  return aptosRequest(
-    {
-      url,
-      method: "GET",
-      originMethod,
-      path,
-      contentType,
-      acceptType,
-      params,
-      overrides: {
-        ...aptosConfig.clientConfig,
-        ...overrides
-      }
-    },
-    aptosConfig,
-    options.type
-  );
-}
-async function getAptosFullNode(options) {
-  const { aptosConfig } = options;
-  return get({
-    ...options,
-    type: "Fullnode" /* FULLNODE */,
-    overrides: {
-      ...aptosConfig.clientConfig,
-      ...aptosConfig.fullnodeConfig,
-      ...options.overrides,
-      HEADERS: { ...aptosConfig.clientConfig?.HEADERS, ...aptosConfig.fullnodeConfig?.HEADERS }
-    }
-  });
-}
-async function getAptosPepperService(options) {
-  return get({ ...options, type: "Pepper" /* PEPPER */ });
-}
-async function paginateWithCursor(options) {
-  const out = [];
-  let cursor;
-  const requestParams = options.params;
-  do {
-    const response = await get({
-      type: "Fullnode" /* FULLNODE */,
-      aptosConfig: options.aptosConfig,
-      originMethod: options.originMethod,
-      path: options.path,
-      params: requestParams,
-      overrides: options.overrides
-    });
-    cursor = response.headers["x-aptos-cursor"];
-    delete response.headers;
-    out.push(...response.data);
-    requestParams.start = cursor;
-  } while (cursor !== null && cursor !== void 0);
-  return out;
-}
-
-export {
-  get,
-  getAptosFullNode,
-  getAptosPepperService,
-  paginateWithCursor
-};
-//# sourceMappingURL=chunk-LYK4TQZO.mjs.map