@aptos-labs/ts-sdk 6.3.0 → 7.0.0

package/dist/account/Account.d.ts

@@ -0,0 +1,302 @@
+import type { AccountAuthenticator } from "../transactions/authenticator/account.js";
+import { HexInput, SigningScheme, SigningSchemeInput } from "../types/index.js";
+import type { AccountAddress, AccountAddressInput } from "../core/accountAddress.js";
+import { AuthenticationKey } from "../core/authenticationKey.js";
+import { AccountPublicKey, VerifySignatureArgs } from "../core/crypto/publicKey.js";
+import { Ed25519PrivateKey } from "../core/crypto/ed25519.js";
+import { PrivateKeyInput } from "../core/crypto/singleKey.js";
+import { Signature } from "../core/crypto/signature.js";
+import { Ed25519Account } from "./Ed25519Account.js";
+import { SingleKeyAccount } from "./SingleKeyAccount.js";
+import { AnyRawTransaction } from "../transactions/types.js";
+import { AptosConfig } from "../api/aptosConfig.js";
+/**
+ * Arguments for creating an `Ed25519Account` from an `Ed25519PrivateKey`.
+ * To use the SingleKey authentication scheme, set `legacy` to false.
+ *
+ * @param privateKey - The private key used to create the account.
+ * @param address - Optional address for the account.
+ * @param legacy - Indicates whether to use legacy authentication (default is true).
+ * @group Implementation
+ * @category Account (On-Chain Model)
+ */
+export interface CreateEd25519AccountFromPrivateKeyArgs {
+    privateKey: Ed25519PrivateKey;
+    address?: AccountAddressInput;
+    legacy?: true;
+}
+/**
+ * Arguments for creating a `SingleKeyAccount` using an `Ed25519PrivateKey`.
+ * The `legacy` property must be set to false to utilize the `SingleKey` authentication scheme.
+ *
+ * @param privateKey - The Ed25519 private key used for account creation.
+ * @param address - Optional account address input.
+ * @param legacy - Must be false to enable the `SingleKey` authentication scheme.
+ * @group Implementation
+ * @category Account (On-Chain Model)
+ */
+export interface CreateEd25519SingleKeyAccountFromPrivateKeyArgs {
+    privateKey: Ed25519PrivateKey;
+    address?: AccountAddressInput;
+    legacy: false;
+}
+/**
+ * Arguments for creating a `SingleKeyAccount` from a supported private key, excluding `Ed25519PrivateKey`.
+ * The `legacy` argument is always false and cannot be set to true.
+ *
+ * @param privateKey - The private key used to create the account.
+ * @param address - Optional address input for the account.
+ * @param legacy - Always false; cannot be explicitly set to true.
+ * @group Implementation
+ * @category Account (On-Chain Model)
+ */
+export interface CreateSingleKeyAccountFromPrivateKeyArgs {
+    privateKey: PrivateKeyInput;
+    address?: AccountAddressInput;
+    legacy?: false;
+}
+/**
+ * Arguments for creating an `Account` from a private key when the key type is unknown at compile time.
+ *
+ * @param privateKey - The private key used to create the account.
+ * @param address - Optional address for the account.
+ * @param legacy - Optional flag indicating if the account is a legacy account.
+ * @group Implementation
+ * @category Account (On-Chain Model)
+ */
+export interface CreateAccountFromPrivateKeyArgs {
+    privateKey: PrivateKeyInput;
+    address?: AccountAddressInput;
+    legacy?: boolean;
+}
+/**
+ * Arguments for generating an Ed25519 account, specifying the signing scheme and legacy option.
+ *
+ * @param scheme - The signing scheme to use for the account.
+ * @param legacy - Indicates if the account should be created in legacy mode.
+ * @group Implementation
+ * @category Account (On-Chain Model)
+ */
+export interface GenerateEd25519AccountArgs {
+    scheme?: SigningSchemeInput.Ed25519;
+    legacy?: true;
+}
+/**
+ * Arguments for generating a `SingleKeyAccount` with an underlying `Ed25519PrivateKey`.
+ * The `legacy` argument must be set to false to ensure an `Ed25519SingleKeyAccount` is returned.
+ *
+ * @param scheme - Optional signing scheme input for the account.
+ * @param legacy - Indicates whether to use legacy account generation.
+ * @group Implementation
+ * @category Account (On-Chain Model)
+ */
+export interface GenerateEd25519SingleKeyAccountArgs {
+    scheme?: SigningSchemeInput.Ed25519;
+    legacy: false;
+}
+/**
+ * Arguments for generating a `SingleKeyAccount` using a supported private key other than `Ed25519PrivateKey`.
+ * The `legacy` argument is optional and defaults to false, and cannot be set to true.
+ *
+ * @param scheme - The signing scheme to use for the account.
+ * @param legacy - Indicates whether to use legacy account generation (defaults to false).
+ * @group Implementation
+ * @category Account (On-Chain Model)
+ */
+export interface GenerateSingleKeyAccountArgs {
+    scheme: Exclude<SigningSchemeInput, SigningSchemeInput.Ed25519>;
+    legacy?: false;
+}
+/**
+ * Arguments for generating an opaque `Account` when the input signature scheme is unknown at compile time.
+ *
+ * @param scheme - The signing scheme to use for account generation.
+ * @param legacy - Indicates whether to use legacy account generation methods.
+ * @group Implementation
+ * @category Account (On-Chain Model)
+ */
+export interface GenerateAccountArgs {
+    scheme?: SigningSchemeInput;
+    legacy?: boolean;
+}
+/**
+ * Arguments for deriving a private key using a mnemonic phrase and a specified BIP44 path.
+ *
+ * @param path - The BIP44 derivation path for the key.
+ * @param mnemonic - The mnemonic phrase used for key generation.
+ * @group Implementation
+ * @category Account (On-Chain Model)
+ */
+export interface PrivateKeyFromDerivationPathArgs {
+    path: string;
+    mnemonic: string;
+}
+/**
+ * Abstract class representing a generic Aptos account.
+ *
+ * This class serves as a single entry point for account generation, allowing accounts to be created
+ * either through `Account.generate()` or `Account.fromDerivationPath`. Although it is defined as an
+ * abstract class, it should be treated as an interface and enforced using the `implements` keyword.
+ *
+ * Note: Generating an account instance does not create the account on-chain.
+ * @group Implementation
+ * @category Account (On-Chain Model)
+ */
+export declare abstract class Account {
+    /**
+     * Public key associated with the account
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    abstract readonly publicKey: AccountPublicKey;
+    /**
+     * Account address associated with the account
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    abstract readonly accountAddress: AccountAddress;
+    /**
+     * Signing scheme used to sign transactions
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    abstract signingScheme: SigningScheme;
+    /**
+     * Generates a new account based on the specified signing scheme and legacy option.
+     * This function allows you to create an account with either the Ed25519 signing scheme or a different scheme as specified.
+     *
+     * @param args - The arguments for generating the account.
+     * @param args.scheme - The signing scheme to use for account generation. Defaults to Ed25519.
+     * @param args.legacy - Indicates whether to use the legacy account generation method. Defaults to true.
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    static generate(args?: GenerateEd25519AccountArgs): Ed25519Account;
+    static generate(args: GenerateEd25519SingleKeyAccountArgs): SingleKeyAccount;
+    static generate(args: GenerateSingleKeyAccountArgs): SingleKeyAccount;
+    static generate(args: GenerateAccountArgs): Account;
+    /**
+     * Creates an account from a given private key and address.
+     * This function allows you to instantiate an account based on the provided private key,
+     * and it can differentiate between legacy and non-legacy accounts.
+     *
+     * @param args - The arguments for creating the account.
+     * @param args.privateKey - The private key used to create the account.
+     * @param args.address - The address associated with the account.
+     * @param args.legacy - A boolean indicating whether to create a legacy account (default is true).
+     * @returns An instance of either Ed25519Account or SingleKeyAccount based on the provided private key.
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    static fromPrivateKey(args: CreateEd25519AccountFromPrivateKeyArgs): Ed25519Account;
+    static fromPrivateKey(args: CreateSingleKeyAccountFromPrivateKeyArgs): SingleKeyAccount;
+    static fromPrivateKey(args: CreateAccountFromPrivateKeyArgs): SingleKeyAccount;
+    /**
+     * @deprecated use `fromPrivateKey` instead.
+     * Instantiates an account using 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 - The arguments required to create an account from a private key.
+     * @param args.privateKey - The underlying private key for the account.
+     * @param args.address - 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
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    static fromPrivateKeyAndAddress(args: CreateAccountFromPrivateKeyArgs): SingleKeyAccount;
+    /**
+     * Generates an account from a specified derivation path and mnemonic.
+     * This function allows you to create an account using different signing schemes based on the provided arguments.
+     *
+     * @param args - The arguments for generating the account.
+     * @param args.scheme - The signing scheme to use for account generation. Defaults to Ed25519.
+     * @param args.mnemonic - The mnemonic phrase used to derive the account.
+     * @param args.path - The derivation path used to generate the account.
+     * @param args.legacy - A boolean indicating whether to use the legacy account generation method. Defaults to true.
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    static fromDerivationPath(args: GenerateEd25519AccountArgs & PrivateKeyFromDerivationPathArgs): Ed25519Account;
+    static fromDerivationPath(args: GenerateEd25519SingleKeyAccountArgs & PrivateKeyFromDerivationPathArgs): SingleKeyAccount;
+    static fromDerivationPath(args: GenerateSingleKeyAccountArgs & PrivateKeyFromDerivationPathArgs): SingleKeyAccount;
+    static fromDerivationPath(args: GenerateAccountArgs & PrivateKeyFromDerivationPathArgs): Account;
+    /**
+     * Retrieve the authentication key for the associated account using the provided public key.
+     * 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 - The arguments for retrieving the authentication key.
+     * @param args.publicKey - The public key of the account.
+     * @returns The authentication key for the associated account.
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    static authKey(args: {
+        publicKey: AccountPublicKey;
+    }): AuthenticationKey;
+    /**
+     * Sign a message using the available signing capabilities.
+     * @param message the signing message, as binary input
+     * @return the AccountAuthenticator containing the signature, together with the account's public key
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    abstract signWithAuthenticator(message: HexInput): AccountAuthenticator;
+    /**
+     * Sign a transaction using the available signing capabilities.
+     * @param transaction the raw transaction
+     * @return the AccountAuthenticator containing the signature of the transaction, together with the account's public key
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    abstract signTransactionWithAuthenticator(transaction: AnyRawTransaction): AccountAuthenticator;
+    /**
+     * Sign the given message using the available signing capabilities.
+     * @param message in HexInput format
+     * @returns Signature
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    abstract sign(message: HexInput): Signature;
+    /**
+     * Sign the given transaction using the available signing capabilities.
+     * @param transaction the transaction to be signed
+     * @returns Signature
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    abstract signTransaction(transaction: AnyRawTransaction): Signature;
+    /**
+     * Verify the given message and signature with the public key.
+     * This function helps ensure the integrity and authenticity of a message by validating its signature.
+     *
+     * @param args - The arguments for verifying the signature.
+     * @param args.message - The raw message data in HexInput format.
+     * @param args.signature - The signed message signature.
+     * @returns A boolean indicating whether the signature is valid.
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    verifySignature(args: VerifySignatureArgs): boolean;
+    /**
+     * Verify the given message and signature with the public key. It fetches any on chain state if needed for verification.
+     *
+     * @param args - The arguments for verifying the signature.
+     * @param args.aptosConfig - The configuration object for connecting to the Aptos network
+     * @param args.message - Raw message data in HexInput format.
+     * @param args.signature - Signed message signature.
+     * @returns A boolean indicating whether the signature is valid.
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    verifySignatureAsync(args: {
+        aptosConfig: AptosConfig;
+        message: HexInput;
+        signature: Signature;
+    }): Promise<boolean>;
+}
+//# sourceMappingURL=Account.d.ts.map

package/dist/account/Account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Account.d.ts","sourceRoot":"","sources":["../../src/account/Account.ts"],"names":[],"mappings":"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"}

package/dist/account/Account.js

@@ -0,0 +1,104 @@
+import { SigningSchemeInput } from "../types/index.js";
+import { Ed25519PrivateKey } from "../core/crypto/ed25519.js";
+import { Ed25519Account } from "./Ed25519Account.js";
+import { SingleKeyAccount } from "./SingleKeyAccount.js";
+/**
+ * Abstract class representing a generic Aptos account.
+ *
+ * This class serves as a single entry point for account generation, allowing accounts to be created
+ * either through `Account.generate()` or `Account.fromDerivationPath`. Although it is defined as an
+ * abstract class, it should be treated as an interface and enforced using the `implements` keyword.
+ *
+ * Note: Generating an account instance does not create the account on-chain.
+ * @group Implementation
+ * @category Account (On-Chain Model)
+ */
+export class Account {
+    static generate(args = {}) {
+        const { scheme = SigningSchemeInput.Ed25519, legacy = true } = args;
+        if (scheme === SigningSchemeInput.Ed25519 && legacy) {
+            return Ed25519Account.generate();
+        }
+        return SingleKeyAccount.generate({ scheme });
+    }
+    static fromPrivateKey(args) {
+        const { privateKey, address, legacy = true } = args;
+        if (privateKey instanceof Ed25519PrivateKey && legacy) {
+            return new Ed25519Account({
+                privateKey,
+                address,
+            });
+        }
+        return new SingleKeyAccount({ privateKey, address });
+    }
+    /**
+     * @deprecated use `fromPrivateKey` instead.
+     * Instantiates an account using 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 - The arguments required to create an account from a private key.
+     * @param args.privateKey - The underlying private key for the account.
+     * @param args.address - 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
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    static fromPrivateKeyAndAddress(args) {
+        return this.fromPrivateKey(args);
+    }
+    static fromDerivationPath(args) {
+        const { scheme = SigningSchemeInput.Ed25519, mnemonic, path, legacy = true } = args;
+        if (scheme === SigningSchemeInput.Ed25519 && legacy) {
+            return Ed25519Account.fromDerivationPath({ mnemonic, path });
+        }
+        return SingleKeyAccount.fromDerivationPath({ scheme, mnemonic, path });
+    }
+    /**
+     * Retrieve the authentication key for the associated account using the provided public key.
+     * 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 - The arguments for retrieving the authentication key.
+     * @param args.publicKey - The public key of the account.
+     * @returns The authentication key for the associated account.
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    static authKey(args) {
+        const { publicKey } = args;
+        return publicKey.authKey();
+    }
+    /**
+     * Verify the given message and signature with the public key.
+     * This function helps ensure the integrity and authenticity of a message by validating its signature.
+     *
+     * @param args - The arguments for verifying the signature.
+     * @param args.message - The raw message data in HexInput format.
+     * @param args.signature - The signed message signature.
+     * @returns A boolean indicating whether the signature is valid.
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    verifySignature(args) {
+        return this.publicKey.verifySignature(args);
+    }
+    /**
+     * Verify the given message and signature with the public key. It fetches any on chain state if needed for verification.
+     *
+     * @param args - The arguments for verifying the signature.
+     * @param args.aptosConfig - The configuration object for connecting to the Aptos network
+     * @param args.message - Raw message data in HexInput format.
+     * @param args.signature - Signed message signature.
+     * @returns A boolean indicating whether the signature is valid.
+     * @group Implementation
+     * @category Account (On-Chain Model)
+     */
+    async verifySignatureAsync(args) {
+        return this.publicKey.verifySignatureAsync(args);
+    }
+}
+//# sourceMappingURL=Account.js.map

package/dist/account/Account.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Account.js","sourceRoot":"","sources":["../../src/account/Account.ts"],"names":[],"mappings":"AACA,OAAO,EAA2B,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAIhF,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAG9D,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAsIzD;;;;;;;;;;GAUG;AACH,MAAM,OAAgB,OAAO;IAoC3B,MAAM,CAAC,QAAQ,CAAC,OAA4B,EAAE;QAC5C,MAAM,EAAE,MAAM,GAAG,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC;QACpE,IAAI,MAAM,KAAK,kBAAkB,CAAC,OAAO,IAAI,MAAM,EAAE,CAAC;YACpD,OAAO,cAAc,CAAC,QAAQ,EAAE,CAAC;QACnC,CAAC;QACD,OAAO,gBAAgB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;IAC/C,CAAC;IAkBD,MAAM,CAAC,cAAc,CAAC,IAAqC;QACzD,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC;QACpD,IAAI,UAAU,YAAY,iBAAiB,IAAI,MAAM,EAAE,CAAC;YACtD,OAAO,IAAI,cAAc,CAAC;gBACxB,UAAU;gBACV,OAAO;aACR,CAAC,CAAC;QACL,CAAC;QACD,OAAO,IAAI,gBAAgB,CAAC,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,CAAC;IACvD,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,wBAAwB,CAAC,IAAqC;QACnE,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAoBD,MAAM,CAAC,kBAAkB,CAAC,IAA4D;QACpF,MAAM,EAAE,MAAM,GAAG,kBAAkB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,EAAE,GAAG,IAAI,CAAC;QACpF,IAAI,MAAM,KAAK,kBAAkB,CAAC,OAAO,IAAI,MAAM,EAAE,CAAC;YACpD,OAAO,cAAc,CAAC,kBAAkB,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;QAC/D,CAAC;QACD,OAAO,gBAAgB,CAAC,kBAAkB,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;IACzE,CAAC;IAED;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,OAAO,CAAC,IAAqC;QAClD,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC;QAC3B,OAAO,SAAS,CAAC,OAAO,EAAE,CAAC;IAC7B,CAAC;IAsCD;;;;;;;;;;OAUG;IACH,eAAe,CAAC,IAAyB;QACvC,OAAO,IAAI,CAAC,SAAS,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,oBAAoB,CAAC,IAI1B;QACC,OAAO,IAAI,CAAC,SAAS,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;IACnD,CAAC;CACF"}

package/dist/account/AccountUtils.d.ts

@@ -0,0 +1,25 @@
+import { Deserializer } from "../bcs/index.js";
+import { HexInput } from "../types/index.js";
+import { MultiKeyAccount } from "./MultiKeyAccount.js";
+import { Account } from "./Account.js";
+import { Ed25519Account } from "./Ed25519Account.js";
+import { SingleKeyAccount } from "./SingleKeyAccount.js";
+import { KeylessAccount } from "./KeylessAccount.js";
+import { FederatedKeylessAccount } from "./FederatedKeylessAccount.js";
+/**
+ * Utility functions for working with accounts.
+ */
+export declare namespace AccountUtils {
+    function toBytes(account: Account): Uint8Array;
+    function toHexStringWithoutPrefix(account: Account): string;
+    function toHexString(account: Account): string;
+    function deserialize(deserializer: Deserializer): Account;
+    function keylessAccountFromHex(hex: HexInput): KeylessAccount;
+    function federatedKeylessAccountFromHex(hex: HexInput): FederatedKeylessAccount;
+    function multiKeyAccountFromHex(hex: HexInput): MultiKeyAccount;
+    function singleKeyAccountFromHex(hex: HexInput): SingleKeyAccount;
+    function ed25519AccountFromHex(hex: HexInput): Ed25519Account;
+    function fromHex(hex: HexInput): Account;
+    function fromBytes(bytes: Uint8Array): Account;
+}
+//# sourceMappingURL=AccountUtils.d.ts.map

package/dist/account/AccountUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AccountUtils.d.ts","sourceRoot":"","sources":["../../src/account/AccountUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAc,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAuB,QAAQ,EAAiB,MAAM,mBAAmB,CAAC;AACjF,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAqB,gBAAgB,EAAyC,MAAM,uBAAuB,CAAC;AACnH,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAwCvE;;GAEG;AACH,yBAAiB,YAAY,CAAC;IAC5B,SAAgB,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,UAAU,CAkDpD;IAED,SAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAEjE;IAED,SAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAEpD;IAED,SAAgB,WAAW,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAoD/D;IAED,SAAgB,qBAAqB,CAAC,GAAG,EAAE,QAAQ,GAAG,cAAc,CAMnE;IAED,SAAgB,8BAA8B,CAAC,GAAG,EAAE,QAAQ,GAAG,uBAAuB,CAMrF;IAED,SAAgB,sBAAsB,CAAC,GAAG,EAAE,QAAQ,GAAG,eAAe,CAMrE;IAED,SAAgB,uBAAuB,CAAC,GAAG,EAAE,QAAQ,GAAG,gBAAgB,CAMvE;IAED,SAAgB,qBAAqB,CAAC,GAAG,EAAE,QAAQ,GAAG,cAAc,CAMnE;IAED,SAAgB,OAAO,CAAC,GAAG,EAAE,QAAQ,GAAG,OAAO,CAE9C;IAED,SAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAEpD;CACF"}

package/dist/account/AccountUtils.js

@@ -0,0 +1,202 @@
+import { Deserializer, Serializer } from "../bcs/index.js";
+import { AnyPublicKeyVariant, SigningScheme } from "../types/index.js";
+import { MultiKeyAccount } from "./MultiKeyAccount.js";
+import { Ed25519Account } from "./Ed25519Account.js";
+import { isSingleKeySigner, SingleKeyAccount } from "./SingleKeyAccount.js";
+import { KeylessAccount } from "./KeylessAccount.js";
+import { FederatedKeylessAccount } from "./FederatedKeylessAccount.js";
+import { AccountAddress } from "../core/accountAddress.js";
+import { Hex } from "../core/hex.js";
+import { Ed25519PrivateKey } from "../core/crypto/ed25519.js";
+import { Secp256k1PrivateKey } from "../core/crypto/secp256k1.js";
+import { MultiKey } from "../core/crypto/multiKey.js";
+import { getIssAudAndUidVal, ZeroKnowledgeSig } from "../core/crypto/keyless.js";
+import { deserializeSchemeAndAddress } from "./utils.js";
+import { EphemeralKeyPair } from "./EphemeralKeyPair.js";
+function serializeKeylessAccountCommon(account, serializer) {
+    serializer.serializeStr(account.jwt);
+    serializer.serializeStr(account.uidKey);
+    serializer.serializeFixedBytes(account.pepper);
+    account.ephemeralKeyPair.serialize(serializer);
+    if (account.proof === undefined) {
+        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 };
+}
+/**
+ * Utility functions for working with accounts.
+ */
+export var AccountUtils;
+(function (AccountUtils) {
+    function toBytes(account) {
+        const serializer = new Serializer();
+        serializer.serializeU32AsUleb128(account.signingScheme);
+        account.accountAddress.serialize(serializer);
+        switch (account.signingScheme) {
+            case SigningScheme.Ed25519:
+                account.privateKey.serialize(serializer);
+                return serializer.toUint8Array();
+            case SigningScheme.SingleKey: {
+                if (!isSingleKeySigner(account)) {
+                    throw new Error("Account is not a SingleKeySigner");
+                }
+                const anyPublicKey = account.getAnyPublicKey();
+                serializer.serializeU32AsUleb128(anyPublicKey.variant);
+                switch (anyPublicKey.variant) {
+                    case AnyPublicKeyVariant.Keyless: {
+                        const keylessAccount = account;
+                        serializeKeylessAccountCommon(keylessAccount, serializer);
+                        return serializer.toUint8Array();
+                    }
+                    case AnyPublicKeyVariant.FederatedKeyless: {
+                        const federatedKeylessAccount = account;
+                        serializeKeylessAccountCommon(federatedKeylessAccount, serializer);
+                        federatedKeylessAccount.publicKey.jwkAddress.serialize(serializer);
+                        serializer.serializeBool(federatedKeylessAccount.audless);
+                        return serializer.toUint8Array();
+                    }
+                    case AnyPublicKeyVariant.Secp256k1:
+                    case AnyPublicKeyVariant.Ed25519: {
+                        const singleKeyAccount = account;
+                        singleKeyAccount.privateKey.serialize(serializer);
+                        return serializer.toUint8Array();
+                    }
+                    default: {
+                        throw new Error(`Invalid public key variant: ${anyPublicKey.variant}`);
+                    }
+                }
+            }
+            case SigningScheme.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}`);
+        }
+    }
+    AccountUtils.toBytes = toBytes;
+    function toHexStringWithoutPrefix(account) {
+        return Hex.hexInputToStringWithoutPrefix(toBytes(account));
+    }
+    AccountUtils.toHexStringWithoutPrefix = toHexStringWithoutPrefix;
+    function toHexString(account) {
+        return Hex.hexInputToString(toBytes(account));
+    }
+    AccountUtils.toHexString = toHexString;
+    function deserialize(deserializer) {
+        const { address, signingScheme } = deserializeSchemeAndAddress(deserializer);
+        switch (signingScheme) {
+            case SigningScheme.Ed25519: {
+                const privateKey = Ed25519PrivateKey.deserialize(deserializer);
+                return new Ed25519Account({ privateKey, address });
+            }
+            case SigningScheme.SingleKey: {
+                const variantIndex = deserializer.deserializeUleb128AsU32();
+                switch (variantIndex) {
+                    case AnyPublicKeyVariant.Ed25519: {
+                        const privateKey = Ed25519PrivateKey.deserialize(deserializer);
+                        return new SingleKeyAccount({ privateKey, address });
+                    }
+                    case AnyPublicKeyVariant.Secp256k1: {
+                        const privateKey = Secp256k1PrivateKey.deserialize(deserializer);
+                        return new SingleKeyAccount({ privateKey, address });
+                    }
+                    case AnyPublicKeyVariant.Keyless: {
+                        const keylessComponents = deserializeKeylessAccountCommon(deserializer);
+                        const jwtClaims = getIssAudAndUidVal(keylessComponents);
+                        return new KeylessAccount({ ...keylessComponents, ...jwtClaims });
+                    }
+                    case AnyPublicKeyVariant.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 SigningScheme.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}`);
+        }
+    }
+    AccountUtils.deserialize = deserialize;
+    function keylessAccountFromHex(hex) {
+        const account = fromHex(hex);
+        if (!(account instanceof KeylessAccount)) {
+            throw new Error("Deserialization of KeylessAccount failed");
+        }
+        return account;
+    }
+    AccountUtils.keylessAccountFromHex = keylessAccountFromHex;
+    function federatedKeylessAccountFromHex(hex) {
+        const account = fromHex(hex);
+        if (!(account instanceof FederatedKeylessAccount)) {
+            throw new Error("Deserialization of FederatedKeylessAccount failed");
+        }
+        return account;
+    }
+    AccountUtils.federatedKeylessAccountFromHex = federatedKeylessAccountFromHex;
+    function multiKeyAccountFromHex(hex) {
+        const account = fromHex(hex);
+        if (!(account instanceof MultiKeyAccount)) {
+            throw new Error("Deserialization of MultiKeyAccount failed");
+        }
+        return account;
+    }
+    AccountUtils.multiKeyAccountFromHex = multiKeyAccountFromHex;
+    function singleKeyAccountFromHex(hex) {
+        const account = fromHex(hex);
+        if (!(account instanceof SingleKeyAccount)) {
+            throw new Error("Deserialization of SingleKeyAccount failed");
+        }
+        return account;
+    }
+    AccountUtils.singleKeyAccountFromHex = singleKeyAccountFromHex;
+    function ed25519AccountFromHex(hex) {
+        const account = fromHex(hex);
+        if (!(account instanceof Ed25519Account)) {
+            throw new Error("Deserialization of Ed25519Account failed");
+        }
+        return account;
+    }
+    AccountUtils.ed25519AccountFromHex = ed25519AccountFromHex;
+    function fromHex(hex) {
+        return deserialize(Deserializer.fromHex(hex));
+    }
+    AccountUtils.fromHex = fromHex;
+    function fromBytes(bytes) {
+        return fromHex(bytes);
+    }
+    AccountUtils.fromBytes = fromBytes;
+})(AccountUtils || (AccountUtils = {}));
+//# sourceMappingURL=AccountUtils.js.map