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

package/dist/esm/chunk-UGFIWCJQ.mjs

@@ -1,130 +0,0 @@
-import {
-  AbstractKeylessAccount
-} from "./chunk-ILTEOGFF.mjs";
-import {
-  FederatedKeylessPublicKey
-} from "./chunk-6SNGKTWE.mjs";
-import {
-  getIssAudAndUidVal
-} from "./chunk-T573PCIR.mjs";
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.mjs";
-import {
-  Deserializer
-} from "./chunk-NUT2VOX2.mjs";
-
-// src/account/FederatedKeylessAccount.ts
-var FederatedKeylessAccount = class _FederatedKeylessAccount extends AbstractKeylessAccount {
-  /**
-   * Use the static generator `FederatedKeylessAccount.create(...)` instead.
-   * Creates a KeylessAccount instance using the provided parameters.
-   * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.
-   *
-   * @param args - The parameters for creating a KeylessAccount.
-   * @param args.address - Optional account address associated with the KeylessAccount.
-   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
-   * @param args.jwt - A JSON Web Token used for authentication.
-   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
-   * @param args.jwkAddress - The address which stores the JSON Web Key Set (JWKS) used to verify the JWT.
-   * @param args.uidKey - Optional key for user identification, defaults to "sub".
-   * @param args.proofFetchCallback - Optional callback function for fetching proof.
-   */
-  constructor(args) {
-    const publicKey = FederatedKeylessPublicKey.create(args);
-    super({ publicKey, ...args });
-    this.publicKey = publicKey;
-    this.audless = args.audless ?? false;
-  }
-  /**
-   * Serializes the transaction data into a format suitable for transmission or storage.
-   * This function ensures that both the transaction bytes and the proof are properly serialized.
-   *
-   * @param serializer - The serializer instance used to convert the transaction data into bytes.
-   */
-  serialize(serializer) {
-    super.serialize(serializer);
-    this.publicKey.jwkAddress.serialize(serializer);
-  }
-  /**
-   * Deserializes the provided deserializer to create a KeylessAccount instance.
-   * This function extracts necessary components such as the JWT, UID key, pepper, ephemeral key pair, and proof from the deserializer.
-   *
-   * @param deserializer - The deserializer instance used to retrieve the serialized data.
-   * @returns A KeylessAccount instance created from the deserialized data.
-   */
-  static deserialize(deserializer) {
-    const { address, proof, ephemeralKeyPair, jwt, uidKey, pepper, verificationKeyHash } = AbstractKeylessAccount.partialDeserialize(deserializer);
-    const jwkAddress = AccountAddress.deserialize(deserializer);
-    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });
-    return new _FederatedKeylessAccount({
-      address,
-      proof,
-      ephemeralKeyPair,
-      iss,
-      uidKey,
-      uidVal,
-      aud,
-      pepper,
-      jwt,
-      verificationKeyHash,
-      jwkAddress
-    });
-  }
-  /**
-   * Deserialize bytes using this account's information.
-   *
-   * @param bytes The bytes being interpreted.
-   * @returns
-   */
-  static fromBytes(bytes) {
-    return _FederatedKeylessAccount.deserialize(Deserializer.fromHex(bytes));
-  }
-  /**
-   * Creates a KeylessAccount instance using the provided parameters.
-   * This function allows you to set up a KeylessAccount with specific attributes such as address, proof, and JWT.
-   * This is used instead of the KeylessAccount constructor.
-   *
-   * @param args - The parameters for creating a KeylessAccount.
-   * @param args.address - Optional account address associated with the KeylessAccount.
-   * @param args.proof - A Zero Knowledge Signature or a promise that resolves to one.
-   * @param args.jwt - A JSON Web Token used for authentication.
-   * @param args.ephemeralKeyPair - The ephemeral key pair used in the account creation.
-   * @param args.jwkAddress - The address which stores the JSON Web Key Set (JWKS) used to verify the JWT.
-   * @param args.uidKey - Optional key for user identification, defaults to "sub".
-   * @param args.proofFetchCallback - Optional callback function for fetching proof.
-   */
-  static create(args) {
-    const {
-      address,
-      proof,
-      jwt,
-      ephemeralKeyPair,
-      pepper,
-      jwkAddress,
-      uidKey = "sub",
-      proofFetchCallback,
-      verificationKey
-    } = args;
-    const { iss, aud, uidVal } = getIssAudAndUidVal({ jwt, uidKey });
-    return new _FederatedKeylessAccount({
-      address,
-      proof,
-      ephemeralKeyPair,
-      iss,
-      uidKey,
-      uidVal,
-      aud,
-      pepper,
-      jwkAddress: AccountAddress.from(jwkAddress),
-      jwt,
-      proofFetchCallback,
-      verificationKeyHash: verificationKey ? verificationKey.hash() : void 0
-    });
-  }
-};
-
-export {
-  FederatedKeylessAccount
-};
-//# sourceMappingURL=chunk-UGFIWCJQ.mjs.map

package/dist/esm/chunk-UGKZQUGE.mjs

@@ -1,367 +0,0 @@
-import {
-  TypeTag
-} from "./chunk-DDZGHA66.mjs";
-import {
-  ModuleId
-} from "./chunk-FMNMYKYH.mjs";
-import {
-  Identifier
-} from "./chunk-MFFBZ43D.mjs";
-import {
-  AccountAddress
-} from "./chunk-CXLXUSCG.mjs";
-import {
-  MoveVector,
-  Serialized
-} from "./chunk-KSK3XIGF.mjs";
-import {
-  Bool,
-  U128,
-  U16,
-  U256,
-  U32,
-  U64,
-  U8
-} from "./chunk-QSYWLSSN.mjs";
-import {
-  EntryFunctionBytes
-} from "./chunk-6ASWESA2.mjs";
-import {
-  Serializable
-} from "./chunk-C7T6GW5P.mjs";
-
-// src/transactions/instances/transactionPayload.ts
-function deserializeFromScriptArgument(deserializer) {
-  const index = deserializer.deserializeUleb128AsU32();
-  switch (index) {
-    case 0 /* U8 */:
-      return U8.deserialize(deserializer);
-    case 1 /* U64 */:
-      return U64.deserialize(deserializer);
-    case 2 /* U128 */:
-      return U128.deserialize(deserializer);
-    case 3 /* Address */:
-      return AccountAddress.deserialize(deserializer);
-    case 4 /* U8Vector */:
-      return MoveVector.deserialize(deserializer, U8);
-    case 5 /* Bool */:
-      return Bool.deserialize(deserializer);
-    case 6 /* U16 */:
-      return U16.deserialize(deserializer);
-    case 7 /* U32 */:
-      return U32.deserialize(deserializer);
-    case 8 /* U256 */:
-      return U256.deserialize(deserializer);
-    case 9 /* Serialized */:
-      return Serialized.deserialize(deserializer);
-    default:
-      throw new Error(`Unknown variant index for ScriptTransactionArgument: ${index}`);
-  }
-}
-var TransactionPayload = class extends Serializable {
-  /**
-   * Deserialize a Transaction Payload
-   * @group Implementation
-   * @category Transactions
-   */
-  /**
-   * Deserializes a multisig transaction payload from the provided deserializer.
-   * This function enables the reconstruction of a MultiSigTransactionPayload object from its serialized form.
-   *
-   * @param deserializer - The deserializer instance used to read the serialized data.
-   * @group Implementation
-   * @category Transactions
-   */
-  static deserialize(deserializer) {
-    const index = deserializer.deserializeUleb128AsU32();
-    switch (index) {
-      case 0 /* Script */:
-        return TransactionPayloadScript.load(deserializer);
-      case 2 /* EntryFunction */:
-        return TransactionPayloadEntryFunction.load(deserializer);
-      case 3 /* Multisig */:
-        return TransactionPayloadMultiSig.load(deserializer);
-      default:
-        throw new Error(`Unknown variant index for TransactionPayload: ${index}`);
-    }
-  }
-};
-var TransactionPayloadScript = class _TransactionPayloadScript extends TransactionPayload {
-  /**
-   * Initializes a multi-sig account transaction with the provided payload.
-   *
-   * @param script - The payload of the multi-sig transaction. This can only be an EntryFunction for now, but Script might be
-   * supported in the future.
-   * @group Implementation
-   * @category Transactions
-   */
-  constructor(script) {
-    super();
-    this.script = script;
-  }
-  /**
-   * Serializes the transaction payload, enabling future support for multiple types of inner transaction payloads.
-   *
-   * @param serializer - The serializer instance used to serialize the transaction data.
-   * @group Implementation
-   * @category Transactions
-   */
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(0 /* Script */);
-    this.script.serialize(serializer);
-  }
-  /**
-   * Loads a MultiSig transaction payload from the provided deserializer.
-   * This function helps in reconstructing a MultiSig transaction payload from its serialized form.
-   *
-   * @param deserializer - The deserializer used to read the serialized data.
-   * @group Implementation
-   * @category Transactions
-   */
-  static load(deserializer) {
-    const script = Script.deserialize(deserializer);
-    return new _TransactionPayloadScript(script);
-  }
-};
-var TransactionPayloadEntryFunction = class _TransactionPayloadEntryFunction extends TransactionPayload {
-  constructor(entryFunction) {
-    super();
-    this.entryFunction = entryFunction;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(2 /* EntryFunction */);
-    this.entryFunction.serialize(serializer);
-  }
-  static load(deserializer) {
-    const entryFunction = EntryFunction.deserialize(deserializer);
-    return new _TransactionPayloadEntryFunction(entryFunction);
-  }
-};
-var TransactionPayloadMultiSig = class _TransactionPayloadMultiSig extends TransactionPayload {
-  constructor(multiSig) {
-    super();
-    this.multiSig = multiSig;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(3 /* Multisig */);
-    this.multiSig.serialize(serializer);
-  }
-  static load(deserializer) {
-    const value = MultiSig.deserialize(deserializer);
-    return new _TransactionPayloadMultiSig(value);
-  }
-};
-var EntryFunction = class _EntryFunction {
-  /**
-   * Contains the payload to run a function within a module.
-   * @param module_name Fully qualified module name in format "account_address::module_name" e.g. "0x1::coin"
-   * @param function_name The function name. e.g "transfer"
-   * @param type_args Type arguments that move function requires.
-   *
-   * @example
-   * A coin transfer function has one type argument "CoinType".
-   * ```
-   * public entry fun transfer<CoinType>(from: &signer, to: address, amount: u64)
-   * ```
-   * @param args arguments to the move function.
-   *
-   * @example
-   * A coin transfer function has three arguments "from", "to" and "amount".
-   * ```
-   * public entry fun transfer<CoinType>(from: &signer, to: address, amount: u64)
-   * ```
-   * @group Implementation
-   * @category Transactions
-   */
-  constructor(module_name, function_name, type_args, args) {
-    this.module_name = module_name;
-    this.function_name = function_name;
-    this.type_args = type_args;
-    this.args = args;
-  }
-  /**
-   * Build an EntryFunction payload from raw primitive values.
-   *
-   * @param module_id - Fully qualified module name in the format "AccountAddress::module_id", e.g., "0x1::coin".
-   * @param function_name - The name of the function to be called.
-   * @param type_args - Type arguments that the Move function requires.
-   * @param args - Arguments to the Move function.
-   *
-   * @example
-   * A coin transfer function has one type argument "CoinType".
-   * ```
-   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64)
-   * ```
-   *
-   * A coin transfer function has three arguments "from", "to", and "amount".
-   * ```
-   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64)
-   * ```
-   *
-   * @returns EntryFunction
-   * @group Implementation
-   * @category Transactions
-   */
-  static build(module_id, function_name, type_args, args) {
-    return new _EntryFunction(ModuleId.fromStr(module_id), new Identifier(function_name), type_args, args);
-  }
-  serialize(serializer) {
-    this.module_name.serialize(serializer);
-    this.function_name.serialize(serializer);
-    serializer.serializeVector(this.type_args);
-    serializer.serializeU32AsUleb128(this.args.length);
-    this.args.forEach((item) => {
-      item.serializeForEntryFunction(serializer);
-    });
-  }
-  /**
-   * Deserializes an entry function payload with the arguments represented as EntryFunctionBytes instances.
-   * @see EntryFunctionBytes
-   *
-   * NOTE: When you deserialize an EntryFunction payload with this method, the entry function
-   * arguments are populated into the deserialized instance as type-agnostic, raw fixed bytes
-   * in the form of the EntryFunctionBytes class.
-   *
-   * In order to correctly deserialize these arguments as their actual type representations, you
-   * must know the types of the arguments beforehand and deserialize them yourself individually.
-   *
-   * One way you could achieve this is by using the ABIs for an entry function and deserializing each
-   * argument as its given, corresponding type.
-   *
-   * @param deserializer
-   * @returns A deserialized EntryFunction payload for a transaction.
-   *
-   * @group Implementation
-   * @category Transactions
-   */
-  static deserialize(deserializer) {
-    const module_name = ModuleId.deserialize(deserializer);
-    const function_name = Identifier.deserialize(deserializer);
-    const type_args = deserializer.deserializeVector(TypeTag);
-    const length = deserializer.deserializeUleb128AsU32();
-    const args = new Array();
-    for (let i = 0; i < length; i += 1) {
-      const fixedBytesLength = deserializer.deserializeUleb128AsU32();
-      const fixedBytes = EntryFunctionBytes.deserialize(deserializer, fixedBytesLength);
-      args.push(fixedBytes);
-    }
-    return new _EntryFunction(module_name, function_name, type_args, args);
-  }
-};
-var Script = class _Script {
-  /**
-   * Scripts contain the Move bytecodes payload that can be submitted to Aptos chain for execution.
-   *
-   * @param bytecode The move module bytecode
-   * @param type_args The type arguments that the bytecode function requires.
-   *
-   * @example
-   * A coin transfer function has one type argument "CoinType".
-   * ```
-   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64)
-   * ```
-   * @param args The arguments that the bytecode function requires.
-   *
-   * @example
-   * A coin transfer function has three arguments "from", "to" and "amount".
-   * ```
-   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64)
-   * ```
-   * @group Implementation
-   * @category Transactions
-   */
-  constructor(bytecode, type_args, args) {
-    this.bytecode = bytecode;
-    this.type_args = type_args;
-    this.args = args;
-  }
-  serialize(serializer) {
-    serializer.serializeBytes(this.bytecode);
-    serializer.serializeVector(this.type_args);
-    serializer.serializeU32AsUleb128(this.args.length);
-    this.args.forEach((item) => {
-      item.serializeForScriptFunction(serializer);
-    });
-  }
-  static deserialize(deserializer) {
-    const bytecode = deserializer.deserializeBytes();
-    const type_args = deserializer.deserializeVector(TypeTag);
-    const length = deserializer.deserializeUleb128AsU32();
-    const args = new Array();
-    for (let i = 0; i < length; i += 1) {
-      const scriptArgument = deserializeFromScriptArgument(deserializer);
-      args.push(scriptArgument);
-    }
-    return new _Script(bytecode, type_args, args);
-  }
-};
-var MultiSig = class _MultiSig {
-  /**
-   * Contains the payload to run a multi-sig account transaction.
-   *
-   * @param multisig_address The multi-sig account address the transaction will be executed as.
-   *
-   * @param transaction_payload The payload of the multi-sig transaction. This is optional when executing a multi-sig
-   *  transaction whose payload is already stored on chain.
-   * @group Implementation
-   * @category Transactions
-   */
-  constructor(multisig_address, transaction_payload) {
-    this.multisig_address = multisig_address;
-    this.transaction_payload = transaction_payload;
-  }
-  serialize(serializer) {
-    this.multisig_address.serialize(serializer);
-    if (this.transaction_payload === void 0) {
-      serializer.serializeBool(false);
-    } else {
-      serializer.serializeBool(true);
-      this.transaction_payload.serialize(serializer);
-    }
-  }
-  static deserialize(deserializer) {
-    const multisig_address = AccountAddress.deserialize(deserializer);
-    const payloadPresent = deserializer.deserializeBool();
-    let transaction_payload;
-    if (payloadPresent) {
-      transaction_payload = MultiSigTransactionPayload.deserialize(deserializer);
-    }
-    return new _MultiSig(multisig_address, transaction_payload);
-  }
-};
-var MultiSigTransactionPayload = class _MultiSigTransactionPayload extends Serializable {
-  /**
-   * Contains the payload to run a multi-sig account transaction.
-   *
-   * @param transaction_payload The payload of the multi-sig transaction.
-   * This can only be EntryFunction for now but,
-   * Script might be supported in the future.
-   * @group Implementation
-   * @category Transactions
-   */
-  constructor(transaction_payload) {
-    super();
-    this.transaction_payload = transaction_payload;
-  }
-  serialize(serializer) {
-    serializer.serializeU32AsUleb128(0);
-    this.transaction_payload.serialize(serializer);
-  }
-  static deserialize(deserializer) {
-    deserializer.deserializeUleb128AsU32();
-    return new _MultiSigTransactionPayload(EntryFunction.deserialize(deserializer));
-  }
-};
-
-export {
-  deserializeFromScriptArgument,
-  TransactionPayload,
-  TransactionPayloadScript,
-  TransactionPayloadEntryFunction,
-  TransactionPayloadMultiSig,
-  EntryFunction,
-  Script,
-  MultiSig,
-  MultiSigTransactionPayload
-};
-//# sourceMappingURL=chunk-UGKZQUGE.mjs.map

package/dist/esm/chunk-UIRAXHDH.mjs

@@ -1 +0,0 @@
-//# sourceMappingURL=chunk-UIRAXHDH.mjs.map

package/dist/esm/chunk-UIRAXHDH.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}