@aptos-labs/ts-sdk/dist/account/AbstractedAccount.js

Aptos TypeScript SDK

import { sha3_256 } from "@noble/hashes/sha3.js";
import { Hex } from "../core/hex.js";
import { AbstractPublicKey, AbstractSignature } from "../core/crypto/abstraction.js";
import { SigningScheme } from "../types/index.js";
import { Account } from "./Account.js";
import { generateSigningMessage, generateSigningMessageForTransaction, } from "../transactions/transactionBuilder/signingMessage.js";
import { AccountAbstractionMessage, AccountAuthenticatorAbstraction } from "../transactions/authenticator/account.js";
import { Serializer } from "../bcs/serializer.js";
import { isValidFunctionInfo } from "../utils/helpers.js";
import { ACCOUNT_ABSTRACTION_SIGNING_DATA_SALT } from "../utils/const.js";
export class AbstractedAccount extends Account {
    publicKey;
    accountAddress;
    authenticationFunction;
    signingScheme = SigningScheme.SingleKey;
    constructor({ signer, accountAddress, authenticationFunction }) {
        super();
        if (!isValidFunctionInfo(authenticationFunction)) {
            throw new Error(`Invalid authentication function ${authenticationFunction} passed into AbstractedAccount`);
        }
        this.authenticationFunction = authenticationFunction;
        this.accountAddress = accountAddress;
        this.publicKey = new AbstractPublicKey(this.accountAddress);
        this.sign = (digest) => new AbstractSignature(signer(digest));
    }
    /**
     * Creates an `AbstractedAccount` from an `Ed25519Account` that has a permissioned signer function and
     * using the `0x1::permissioned_delegation::authenticate` function to verify the signature.
     *
     * @param signer - The `Ed25519Account` that can be used to sign permissioned transactions.
     * @returns The `AbstractedAccount`
     */
    static fromPermissionedSigner({ signer, accountAddress, }) {
        return new AbstractedAccount({
            signer: (digest) => {
                const serializer = new Serializer();
                signer.publicKey.serialize(serializer);
                signer.sign(digest).serialize(serializer);
                return serializer.toUint8Array();
            },
            accountAddress: accountAddress ?? signer.accountAddress,
            authenticationFunction: "0x1::permissioned_delegation::authenticate",
        });
    }
    static generateAccountAbstractionMessage(message, functionInfo) {
        const accountAbstractionMessage = new AccountAbstractionMessage(message, functionInfo);
        return generateSigningMessage(accountAbstractionMessage.bcsToBytes(), ACCOUNT_ABSTRACTION_SIGNING_DATA_SALT);
    }
    signWithAuthenticator(message) {
        const messageBytes = Hex.fromHexInput(message).toUint8Array();
        return new AccountAuthenticatorAbstraction(this.authenticationFunction, sha3_256(messageBytes), this.sign(sha3_256(messageBytes)).toUint8Array());
    }
    signTransactionWithAuthenticator(transaction) {
        const message = AbstractedAccount.generateAccountAbstractionMessage(generateSigningMessageForTransaction(transaction), this.authenticationFunction);
        return this.signWithAuthenticator(message);
    }
    sign;
    signTransaction(transaction) {
        return this.sign(generateSigningMessageForTransaction(transaction));
    }
    /**
     * Update the signer function for the account. This can be done after asynchronous operations are complete
     * to update the context of the signer function.
     *
     * @param signer - The new signer function to use for the account.
     */
    setSigner(signer) {
        this.sign = (digest) => new AbstractSignature(signer(digest));
    }
}
//# sourceMappingURL=AbstractedAccount.js.map