@moveindustries/ts-sdk 5.1.4

package/src/account/Account.ts

@@ -0,0 +1,354 @@
+import type { MovementConfig } from "../api";
+import type { AccountAddress, AccountAddressInput } from "../core/accountAddress";
+import { AuthenticationKey } from "../core/authenticationKey";
+import { AccountPublicKey, Ed25519PrivateKey, PrivateKeyInput, Signature, VerifySignatureArgs } from "../core/crypto";
+import type { AccountAuthenticator } from "../transactions/authenticator/account";
+import { AnyRawTransaction } from "../transactions/types";
+import { HexInput, SigningScheme, SigningSchemeInput } from "../types";
+import { Ed25519Account } from "./Ed25519Account";
+import { SingleKeyAccount } from "./SingleKeyAccount";
+
+/**
+ * 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 Movement 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 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;
+  static generate(args: GenerateAccountArgs = {}) {
+    const { scheme = SigningSchemeInput.Ed25519, legacy = true } = args;
+    if (scheme === SigningSchemeInput.Ed25519 && legacy) {
+      return Ed25519Account.generate();
+    }
+    return SingleKeyAccount.generate({ scheme });
+  }
+
+  /**
+   * 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;
+  static fromPrivateKey(args: CreateAccountFromPrivateKeyArgs): Ed25519Account | SingleKeyAccount {
+    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: CreateAccountFromPrivateKeyArgs) {
+    return this.fromPrivateKey(args);
+  }
+
+  /**
+   * 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;
+  static fromDerivationPath(args: GenerateAccountArgs & PrivateKeyFromDerivationPathArgs) {
+    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://movement.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 {
+    const { publicKey } = args;
+    return publicKey.authKey();
+  }
+
+  /**
+   * 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 {
+    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.movementConfig - The configuration object for connecting to the Movement 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: {
+    movementConfig: MovementConfig;
+    message: HexInput;
+    signature: Signature;
+  }): Promise<boolean> {
+    return this.publicKey.verifySignatureAsync(args);
+  }
+}

package/src/account/AccountUtils.ts

@@ -0,0 +1,216 @@
+import { Deserializer, Serializer } from "../bcs";
+import { AnyPublicKeyVariant, HexInput, SigningScheme } from "../types";
+import { MultiKeyAccount } from "./MultiKeyAccount";
+import { Account } from "./Account";
+import { Ed25519Account } from "./Ed25519Account";
+import { isSingleKeySigner, SingleKeyAccount, SingleKeySignerOrLegacyEd25519Account } from "./SingleKeyAccount";
+import { KeylessAccount } from "./KeylessAccount";
+import { FederatedKeylessAccount } from "./FederatedKeylessAccount";
+import { AbstractKeylessAccount } from "./AbstractKeylessAccount";
+import {
+  AccountAddress,
+  Ed25519PrivateKey,
+  getIssAudAndUidVal,
+  Hex,
+  MultiKey,
+  Secp256k1PrivateKey,
+  ZeroKnowledgeSig,
+} from "../core";
+import { deserializeSchemeAndAddress } from "./utils";
+import { EphemeralKeyPair } from "./EphemeralKeyPair";
+
+function serializeKeylessAccountCommon(account: AbstractKeylessAccount, serializer: Serializer): void {
+  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: Deserializer): {
+  jwt: string;
+  uidKey: string;
+  pepper: Uint8Array;
+  ephemeralKeyPair: EphemeralKeyPair;
+  proof: ZeroKnowledgeSig;
+  verificationKeyHash?: Uint8Array;
+} {
+  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 namespace AccountUtils {
+  export function toBytes(account: Account): Uint8Array {
+    const serializer = new Serializer();
+    serializer.serializeU32AsUleb128(account.signingScheme);
+    account.accountAddress.serialize(serializer);
+    switch (account.signingScheme) {
+      case SigningScheme.Ed25519:
+        (account as Ed25519Account).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 as KeylessAccount;
+            serializeKeylessAccountCommon(keylessAccount, serializer);
+            return serializer.toUint8Array();
+          }
+          case AnyPublicKeyVariant.FederatedKeyless: {
+            const federatedKeylessAccount = account as FederatedKeylessAccount;
+            serializeKeylessAccountCommon(federatedKeylessAccount, serializer);
+            federatedKeylessAccount.publicKey.jwkAddress.serialize(serializer);
+            serializer.serializeBool(federatedKeylessAccount.audless);
+            return serializer.toUint8Array();
+          }
+          case AnyPublicKeyVariant.Secp256k1:
+          case AnyPublicKeyVariant.Ed25519: {
+            const singleKeyAccount = account as SingleKeyAccount;
+            singleKeyAccount.privateKey.serialize(serializer);
+            return serializer.toUint8Array();
+          }
+          default: {
+            throw new Error(`Invalid public key variant: ${anyPublicKey.variant}`);
+          }
+        }
+      }
+      case SigningScheme.MultiKey: {
+        const multiKeyAccount = account as MultiKeyAccount;
+        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}`);
+    }
+  }
+
+  export function toHexStringWithoutPrefix(account: Account): string {
+    return Hex.hexInputToStringWithoutPrefix(toBytes(account));
+  }
+
+  export function toHexString(account: Account): string {
+    return Hex.hexInputToString(toBytes(account));
+  }
+
+  export function deserialize(deserializer: Deserializer): Account {
+    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<SingleKeySignerOrLegacyEd25519Account>();
+        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}`);
+    }
+  }
+
+  export function keylessAccountFromHex(hex: HexInput): KeylessAccount {
+    const account = fromHex(hex);
+    if (!(account instanceof KeylessAccount)) {
+      throw new Error("Deserialization of KeylessAccount failed");
+    }
+    return account;
+  }
+
+  export function federatedKeylessAccountFromHex(hex: HexInput): FederatedKeylessAccount {
+    const account = fromHex(hex);
+    if (!(account instanceof FederatedKeylessAccount)) {
+      throw new Error("Deserialization of FederatedKeylessAccount failed");
+    }
+    return account;
+  }
+
+  export function multiKeyAccountFromHex(hex: HexInput): MultiKeyAccount {
+    const account = fromHex(hex);
+    if (!(account instanceof MultiKeyAccount)) {
+      throw new Error("Deserialization of MultiKeyAccount failed");
+    }
+    return account;
+  }
+
+  export function singleKeyAccountFromHex(hex: HexInput): SingleKeyAccount {
+    const account = fromHex(hex);
+    if (!(account instanceof SingleKeyAccount)) {
+      throw new Error("Deserialization of SingleKeyAccount failed");
+    }
+    return account;
+  }
+
+  export function ed25519AccountFromHex(hex: HexInput): Ed25519Account {
+    const account = fromHex(hex);
+    if (!(account instanceof Ed25519Account)) {
+      throw new Error("Deserialization of Ed25519Account failed");
+    }
+    return account;
+  }
+
+  export function fromHex(hex: HexInput): Account {
+    return deserialize(Deserializer.fromHex(hex));
+  }
+
+  export function fromBytes(bytes: Uint8Array): Account {
+    return fromHex(bytes);
+  }
+}

package/src/account/DerivableAbstractedAccount.ts

@@ -0,0 +1,103 @@
+import { sha3_256 } from "@noble/hashes/sha3";
+import { Serializer } from "../bcs/serializer";
+import { AccountAddress } from "../core/accountAddress";
+import { AccountAbstractionMessage, AccountAuthenticatorAbstraction } from "../transactions/authenticator/account";
+import { HexInput } from "../types";
+import { isValidFunctionInfo } from "../utils/helpers";
+import { AbstractedAccount } from "./AbstractedAccount";
+import { generateSigningMessage } from "../transactions/transactionBuilder/signingMessage";
+import { ACCOUNT_ABSTRACTION_SIGNING_DATA_SALT } from "../utils/const";
+
+type DerivableAbstractedAccountArgs = {
+  /**
+   * The signer function signs transactions and returns the `authenticator` bytes in the `AbstractionAuthData`.
+   *
+   * @param digest - The SHA256 hash of the transaction signing message
+   * @returns The `authenticator` bytes that can be used to verify the signature.
+   */
+  signer: (digest: HexInput) => Uint8Array;
+
+  /**
+   * The authentication function that will be used to verify the signature.
+   *
+   * @example
+   * ```ts
+   * const authenticationFunction = `${accountAddress}::permissioned_delegation::authenticate`;
+   * ```
+   */
+  authenticationFunction: string;
+
+  /**
+   * The abstract public key that is used to identify the account.
+   * Depends on the use cases, most of the time it is the public key of the source wallet
+   */
+  abstractPublicKey: Uint8Array;
+};
+
+export class DerivableAbstractedAccount extends AbstractedAccount {
+  /**
+   * The abstract public key that is used to identify the account.
+   * Depends on the use cases, most of the time it is the public key of the source wallet
+   */
+  readonly abstractPublicKey: Uint8Array;
+
+  /**
+   * The domain separator used to calculate the DAA account address.
+   */
+  static readonly ADDRESS_DOMAIN_SEPERATOR: number = 5;
+
+  constructor({ signer, authenticationFunction, abstractPublicKey }: DerivableAbstractedAccountArgs) {
+    const daaAccountAddress = new AccountAddress(
+      DerivableAbstractedAccount.computeAccountAddress(authenticationFunction, abstractPublicKey),
+    );
+    super({
+      accountAddress: daaAccountAddress,
+      signer,
+      authenticationFunction,
+    });
+    this.abstractPublicKey = abstractPublicKey;
+  }
+
+  /**
+   * Compute the account address of the DAA
+   * The DAA account address is computed by hashing the function info and the account identity
+   * and appending the domain separator (5)
+   *
+   * @param functionInfo - The authentication function
+   * @param accountIdentifier - The account identity
+   * @returns The account address
+   */
+  static computeAccountAddress(functionInfo: string, accountIdentifier: Uint8Array): Uint8Array {
+    if (!isValidFunctionInfo(functionInfo)) {
+      throw new Error(`Invalid authentication function ${functionInfo} passed into DerivableAbstractedAccount`);
+    }
+    const [moduleAddress, moduleName, functionName] = functionInfo.split("::");
+
+    const hash = sha3_256.create();
+    // Serialize and append the function info
+    const serializer = new Serializer();
+    AccountAddress.fromString(moduleAddress).serialize(serializer);
+    serializer.serializeStr(moduleName);
+    serializer.serializeStr(functionName);
+    hash.update(serializer.toUint8Array());
+
+    // Serialize and append the account identity
+    const s2 = new Serializer();
+    s2.serializeBytes(accountIdentifier);
+    hash.update(s2.toUint8Array());
+
+    // Append the domain separator
+    hash.update(new Uint8Array([DerivableAbstractedAccount.ADDRESS_DOMAIN_SEPERATOR]));
+
+    return hash.digest();
+  }
+
+  signWithAuthenticator(message: HexInput): AccountAuthenticatorAbstraction {
+    return new AccountAuthenticatorAbstraction(
+      this.authenticationFunction,
+      sha3_256(message),
+      this.sign(sha3_256(message)).value,
+      this.abstractPublicKey,
+    );
+  }
+}