@pendulum-chain/api-solang/build/esm/submitExtrinsic.js

Interface to interact with smart contracts compiled via Solang

import { extractDispatchErrorDescription } from "./dispatchError.js";
export function getSignerAddress(signer) {
    switch (signer.type) {
        case "keypair":
            return signer.keypair.address;
        case "signer":
            return signer.address;
    }
}
export async function signAndSubmitExtrinsic(extrinsic, signer) {
    const signedExtrinsic = await signExtrinsic(extrinsic, signer);
    return submitExtrinsic(signedExtrinsic);
}
export async function signExtrinsic(extrinsic, signer) {
    let account;
    let signerOptions;
    switch (signer.type) {
        case "keypair":
            account = signer.keypair;
            signerOptions = { nonce: -1 };
            break;
        case "signer":
            account = signer.address;
            signerOptions = { nonce: -1, signer: signer.signer };
            break;
    }
    return extrinsic.signAsync(account, signerOptions);
}
export async function submitExtrinsic(extrinsic) {
    return await new Promise(async (resolve, reject) => {
        try {
            const unsub = await extrinsic.send((update) => {
                const { status, events: eventRecords, txHash, txIndex } = update;
                if (status.isInBlock || status.isFinalized) {
                    let transactionFee = undefined;
                    let status = undefined;
                    for (const eventRecord of eventRecords) {
                        const { data, section, method } = eventRecord.event;
                        if (section === "transactionPayment" && method === "TransactionFeePaid") {
                            const [, actualFee] = data;
                            transactionFee = actualFee.toBigInt();
                        }
                        if (section === "system" && method === "ExtrinsicFailed") {
                            const [dispatchError] = data;
                            status = {
                                type: "error",
                                error: extractDispatchErrorDescription(dispatchError),
                            };
                        }
                        if (section === "system" && method === "ExtrinsicSuccess") {
                            status = { type: "success" };
                        }
                    }
                    if (status !== undefined) {
                        unsub();
                        resolve({
                            transactionFee,
                            eventRecords,
                            status,
                            txHash,
                            txIndex,
                        });
                    }
                }
            });
        }
        catch (error) {
            reject(error);
        }
    });
}