common_account_abstractions_utils - [devnet]

use 0x1::chain_id;
use 0x1::string;
use 0x1::string_utils;
use 0x1::transaction_context;
use 0x1::vector;

Constants

Entry function payload is missing.

const EMISSING_ENTRY_FUNCTION_PAYLOAD: u64 = 1;

Functions

network_name

public(friend) fun network_name(): vector<u8>

Implementation

public(friend) fun network_name(): vector<u8> {
    let chain_id = chain_id::get();
    if (chain_id == 1) {
        b"mainnet"
    } else if (chain_id == 2) {
        b"testnet"
    } else if (chain_id == 4) {
        b"local"
    } else {
        let network_name = &mut vector[];
        network_name.append(b"custom network: ");
        network_name.append(*string_utils::to_string(&chain_id).bytes());
        *network_name
    }
}

entry_function_name

public(friend) fun entry_function_name(entry_function_payload: &transaction_context::EntryFunctionPayload): vector<u8>

Implementation

public(friend) fun entry_function_name(entry_function_payload: &EntryFunctionPayload): vector<u8> {
    let entry_function_name = &mut vector[];
    let addr_str = string_utils::to_string(
        &transaction_context::account_address(entry_function_payload)
    ).bytes();
    // .slice(1) to remove the leading '@' char
    entry_function_name.append(addr_str.slice(1, addr_str.length()));
    entry_function_name.append(b"::");
    entry_function_name.append(
        *transaction_context::module_name(entry_function_payload).bytes()
    );
    entry_function_name.append(b"::");
    entry_function_name.append(
        *transaction_context::function_name(entry_function_payload).bytes()
    );
    *entry_function_name
}

construct_message

public(friend) fun construct_message(chain_name: &vector<u8>, account_address: &vector<u8>, domain: &vector<u8>, entry_function_name: &vector<u8>, digest_utf8: &vector<u8>): vector<u8>

Implementation

public(friend) fun construct_message(
    chain_name: &vector<u8>,
    account_address: &vector<u8>,
    domain: &vector<u8>,
    entry_function_name: &vector<u8>,
    digest_utf8: &vector<u8>,
): vector<u8> {
    let message = &mut vector[];
    message.append(*domain);
    message.append(b" wants you to sign in with your ");
    message.append(*chain_name);
    message.append(b" account:\n");
    message.append(*account_address);
    message.append(b"\n\nPlease confirm you explicitly initiated this request from ");
    message.append(*domain);
    message.append(b".");
    message.append(b" You are approving to execute transaction ");
    message.append(*entry_function_name);
    message.append(b" on Aptos blockchain");
    let network_name = network_name();
    message.append(b" (");
    message.append(network_name);
    message.append(b")");
    message.append(b".");
    message.append(b"\n\nNonce: ");
    message.append(*digest_utf8);
    *message
}

daa_authenticate

public(friend) fun daa_authenticate(account: signer, aa_auth_data: auth_data::AbstractionAuthData, auth_fn: |auth_data::AbstractionAuthData, &vector<u8>|): signer

Implementation

public(friend) inline fun daa_authenticate(
    account: signer,
    aa_auth_data: AbstractionAuthData,
    auth_fn: |AbstractionAuthData, &vector<u8>|,
): signer {
    let maybe_entry_function_payload = transaction_context::entry_function_payload();
    if (maybe_entry_function_payload.is_some()) {
        let entry_function_payload = maybe_entry_function_payload.destroy_some();
        let entry_function_name = entry_function_name(&entry_function_payload);

        // call the passed-in function value
        auth_fn(aa_auth_data, &entry_function_name);
        account
    } else {
        abort(EMISSING_ENTRY_FUNCTION_PAYLOAD)
    }
}