@loyal-labs/loyal-smart-accounts-core 0.1.1

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/index.js";

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./src/index.js";

package/dist/internal.d.ts

@@ -0,0 +1 @@
+export * from "./src/internal/index.js";

package/dist/internal.js

@@ -0,0 +1 @@
+export * from "./src/internal/index.js";

package/dist/loyal.d.ts

@@ -0,0 +1 @@
+export * from "./src/loyal.js";

package/dist/loyal.js

@@ -0,0 +1 @@
+export * from "./src/loyal.js";

package/dist/src/accounts.d.ts

@@ -0,0 +1 @@
+export * from "./generated/accounts/index.js";

package/dist/src/accounts.js

@@ -0,0 +1 @@
+export * from "./generated/accounts/index.js";

package/dist/src/codecs.d.ts

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./utils.js";
+export * from "./utils/compileToSynchronousMessage.js";
+export * from "./utils/compileToSynchronousMessageV2.js";
+export * from "./utils/compileToWrappedMessageV0.js";
+export * from "./utils/compiled-keys.js";

package/dist/src/codecs.js

@@ -0,0 +1,6 @@
+export * from "./types.js";
+export * from "./utils.js";
+export * from "./utils/compileToSynchronousMessage.js";
+export * from "./utils/compileToSynchronousMessageV2.js";
+export * from "./utils/compileToWrappedMessageV0.js";
+export * from "./utils/compiled-keys.js";

package/dist/src/core/codecs/index.d.ts

@@ -0,0 +1,6 @@
+export * from "../../types.js";
+export * from "../../utils.js";
+export * from "../../utils/compileToSynchronousMessage.js";
+export * from "../../utils/compileToSynchronousMessageV2.js";
+export * from "../../utils/compileToWrappedMessageV0.js";
+export * from "../../utils/compiled-keys.js";

package/dist/src/core/codecs/index.js

@@ -0,0 +1,6 @@
+export * from "../../types.js";
+export * from "../../utils.js";
+export * from "../../utils/compileToSynchronousMessage.js";
+export * from "../../utils/compileToSynchronousMessageV2.js";
+export * from "../../utils/compileToWrappedMessageV0.js";
+export * from "../../utils/compiled-keys.js";

package/dist/src/core/codecs/primitives.d.ts

@@ -0,0 +1,7 @@
+import { type bignum } from "@metaplex-foundation/beet";
+export declare function toUtfBytes(str: string): Uint8Array;
+export declare function toU8Bytes(num: number): Uint8Array;
+export declare function toU32Bytes(num: number): Uint8Array;
+export declare function toU64Bytes(num: bigint): Uint8Array;
+export declare function toU128Bytes(num: bigint): Uint8Array;
+export declare function toBigInt(number: bignum): bigint;

package/dist/src/core/codecs/primitives.js

@@ -0,0 +1,28 @@
+import { u32, u64, u8, u128 } from "@metaplex-foundation/beet";
+import { Buffer } from "buffer";
+export function toUtfBytes(str) {
+    return new TextEncoder().encode(str);
+}
+export function toU8Bytes(num) {
+    const bytes = Buffer.alloc(1);
+    u8.write(bytes, 0, num);
+    return bytes;
+}
+export function toU32Bytes(num) {
+    const bytes = Buffer.alloc(4);
+    u32.write(bytes, 0, num);
+    return bytes;
+}
+export function toU64Bytes(num) {
+    const bytes = Buffer.alloc(8);
+    u64.write(bytes, 0, num);
+    return bytes;
+}
+export function toU128Bytes(num) {
+    const bytes = Buffer.alloc(16);
+    u128.write(bytes, 0, num);
+    return bytes;
+}
+export function toBigInt(number) {
+    return BigInt(number.toString());
+}

package/dist/src/core/errors/index.d.ts

@@ -0,0 +1,29 @@
+import type { ErrorWithLogs } from "@metaplex-foundation/cusper";
+export * from "../../generated/errors/index.js";
+export declare class LoyalSmartAccountsError extends Error {
+    constructor(message: string);
+}
+export declare class MissingOperationConnectionError extends LoyalSmartAccountsError {
+    constructor(operation: string);
+}
+export declare class MissingRequiredSignerError extends LoyalSmartAccountsError {
+    constructor(operation: string, role: string);
+}
+export declare class InvalidRoleResolutionError extends LoyalSmartAccountsError {
+    constructor(operation: string, role: string);
+}
+export declare class InvalidPayloadError extends LoyalSmartAccountsError {
+    constructor(message: string);
+}
+export declare class MissingLookupTableAccountError extends LoyalSmartAccountsError {
+    constructor(address: string, detail?: string);
+}
+export declare class OperationRegistryCoverageError extends LoyalSmartAccountsError {
+    constructor(message: string);
+}
+export declare class SolanaTransactionLogError extends LoyalSmartAccountsError {
+    readonly logs: string[];
+    constructor(message: string, logs: string[]);
+}
+export declare function translateAndThrowAnchorError(err: unknown): never;
+export declare const isErrorWithLogs: (err: unknown) => err is ErrorWithLogs;

package/dist/src/core/errors/index.js

@@ -0,0 +1,124 @@
+import { initCusper } from "@metaplex-foundation/cusper";
+export * from "../../generated/errors/index.js";
+import { errorFromCode } from "../../generated/index.js";
+export class LoyalSmartAccountsError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "LoyalSmartAccountsError";
+    }
+}
+export class MissingOperationConnectionError extends LoyalSmartAccountsError {
+    constructor(operation) {
+        super(`Operation "${operation}" requires a Solana connection during prepare, but no connection was provided.`);
+        this.name = "MissingOperationConnectionError";
+    }
+}
+export class MissingRequiredSignerError extends LoyalSmartAccountsError {
+    constructor(operation, role) {
+        super(`Operation "${operation}" requires a signer for role "${role}" when sending through the bound client.`);
+        this.name = "MissingRequiredSignerError";
+    }
+}
+export class InvalidRoleResolutionError extends LoyalSmartAccountsError {
+    constructor(operation, role) {
+        super(`Operation "${operation}" could not resolve a PublicKey for required role "${role}".`);
+        this.name = "InvalidRoleResolutionError";
+    }
+}
+export class InvalidPayloadError extends LoyalSmartAccountsError {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidPayloadError";
+    }
+}
+export class MissingLookupTableAccountError extends LoyalSmartAccountsError {
+    constructor(address, detail) {
+        super(detail
+            ? `Address lookup table account ${address} ${detail}`
+            : `Address lookup table account ${address} not found.`);
+        this.name = "MissingLookupTableAccountError";
+    }
+}
+export class OperationRegistryCoverageError extends LoyalSmartAccountsError {
+    constructor(message) {
+        super(message);
+        this.name = "OperationRegistryCoverageError";
+    }
+}
+export class SolanaTransactionLogError extends LoyalSmartAccountsError {
+    logs;
+    constructor(message, logs) {
+        super(message);
+        this.name = "SolanaTransactionLogError";
+        this.logs = logs;
+    }
+}
+const cusper = initCusper(errorFromCode);
+const SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
+const LAMPORTS_PER_SOL = 1000000000n;
+function formatLamports(lamports) {
+    const whole = lamports / LAMPORTS_PER_SOL;
+    const fraction = lamports % LAMPORTS_PER_SOL;
+    if (fraction === 0n) {
+        return `${whole.toString()} SOL`;
+    }
+    const fractionText = fraction.toString().padStart(9, "0").replace(/0+$/, "");
+    return `${whole.toString()}.${fractionText} SOL`;
+}
+function getInsufficientLamportsError(logs) {
+    for (const log of logs) {
+        const match = log.match(/Transfer: insufficient lamports (\d+), need (\d+)/);
+        if (!match) {
+            continue;
+        }
+        const availableLamports = BigInt(match[1]);
+        const neededLamports = BigInt(match[2]);
+        const shortfallLamports = neededLamports - availableLamports;
+        return new SolanaTransactionLogError(`Insufficient SOL to pay transaction rent or fees at the failing instruction. ` +
+            `Available: ${formatLamports(availableLamports)} (${availableLamports.toString()} lamports). ` +
+            `Needed: ${formatLamports(neededLamports)} (${neededLamports.toString()} lamports). ` +
+            `Top up at least ${formatLamports(shortfallLamports)} plus network fees and retry.`, logs);
+    }
+    return null;
+}
+function getAccountAlreadyInUseError(logs) {
+    const alreadyInUseLog = logs.find((log) => /\balready in use\b|\balready initialized\b/i.test(log));
+    if (!alreadyInUseLog) {
+        return null;
+    }
+    return new SolanaTransactionLogError(`Account initialization failed because the target account is already in use. ` +
+        `This create flow is one-shot; refresh the on-chain transaction index and retry with the next PDA, ` +
+        `or close the existing account first if the program permits it. Runtime log: ${alreadyInUseLog}`, logs);
+}
+function getSystemProgramError(logs) {
+    const systemProgramFailure = logs.find((log) => log.startsWith(`Program ${SYSTEM_PROGRAM_ADDRESS} failed:`));
+    if (!systemProgramFailure) {
+        return null;
+    }
+    const reason = systemProgramFailure
+        .replace(`Program ${SYSTEM_PROGRAM_ADDRESS} failed:`, "")
+        .trim();
+    return new SolanaTransactionLogError(`System Program failed while processing the transaction: ${reason}. ` +
+        `Check the preceding simulation logs for the operation that failed.`, logs);
+}
+function getHumanReadableRuntimeError(logs) {
+    return (getInsufficientLamportsError(logs) ??
+        getAccountAlreadyInUseError(logs) ??
+        getSystemProgramError(logs));
+}
+export function translateAndThrowAnchorError(err) {
+    if (!isErrorWithLogs(err)) {
+        throw err;
+    }
+    const translatedError = getHumanReadableRuntimeError(err.logs) ??
+        cusper.errorFromProgramLogs(err.logs) ??
+        err;
+    if (typeof Error.captureStackTrace === "function") {
+        Error.captureStackTrace(translatedError, translateAndThrowAnchorError);
+    }
+    translatedError.logs = err.logs;
+    throw translatedError;
+}
+export const isErrorWithLogs = (err) => {
+    return Boolean(err && typeof err === "object" && "logs" in err && Array.isArray(err.logs));
+};

package/dist/src/core/generated/index.d.ts

@@ -0,0 +1 @@
+export * from "../../generated/index.js";

package/dist/src/core/generated/index.js

@@ -0,0 +1 @@
+export * from "../../generated/index.js";

package/dist/src/core/pda/index.d.ts

@@ -0,0 +1,44 @@
+import { PublicKey } from "@solana/web3.js";
+import { PDA_REGISTRY } from "../spec/pda-registry.js";
+type ProgramIdParam = {
+    programId?: PublicKey;
+};
+export declare function getProgramConfigPda({ programId, }: ProgramIdParam): [PublicKey, number];
+export declare function getSettingsPda({ accountIndex, programId, }: ProgramIdParam & {
+    accountIndex: bigint;
+}): [PublicKey, number];
+export declare function getSmartAccountPda({ settingsPda, accountIndex, programId, }: ProgramIdParam & {
+    settingsPda: PublicKey;
+    accountIndex: number;
+}): [PublicKey, number];
+export declare function getEphemeralSignerPda({ transactionPda, ephemeralSignerIndex, programId, }: ProgramIdParam & {
+    transactionPda: PublicKey;
+    ephemeralSignerIndex: number;
+}): [PublicKey, number];
+export declare function getTransactionPda({ settingsPda, transactionIndex, programId, }: ProgramIdParam & {
+    settingsPda: PublicKey;
+    transactionIndex: bigint;
+}): [PublicKey, number];
+export declare function getProposalPda({ settingsPda, transactionIndex, programId, }: ProgramIdParam & {
+    settingsPda: PublicKey;
+    transactionIndex: bigint;
+}): [PublicKey, number];
+export declare function getBatchTransactionPda({ settingsPda, batchIndex, transactionIndex, programId, }: ProgramIdParam & {
+    settingsPda: PublicKey;
+    batchIndex: bigint;
+    transactionIndex: number;
+}): [PublicKey, number];
+export declare function getSpendingLimitPda({ settingsPda, seed, programId, }: ProgramIdParam & {
+    settingsPda: PublicKey;
+    seed: PublicKey;
+}): [PublicKey, number];
+export declare function getTransactionBufferPda({ consensusPda, creator, bufferIndex, programId, }: ProgramIdParam & {
+    consensusPda: PublicKey;
+    creator: PublicKey;
+    bufferIndex: number;
+}): [PublicKey, number];
+export declare function getPolicyPda({ settingsPda, policySeed, programId, }: ProgramIdParam & {
+    settingsPda: PublicKey;
+    policySeed: number;
+}): [PublicKey, number];
+export { PDA_REGISTRY };

package/dist/src/core/pda/index.js

@@ -0,0 +1,80 @@
+import { PublicKey } from "@solana/web3.js";
+import invariant from "invariant";
+import { PROGRAM_ID } from "../generated/index.js";
+import { PDA_REGISTRY } from "../spec/pda-registry.js";
+import { toU128Bytes, toU32Bytes, toU64Bytes, toU8Bytes, toUtfBytes, } from "../codecs/primitives.js";
+const STATIC_SEED_CACHE = new Map();
+function getStaticSeed(value) {
+    const cached = STATIC_SEED_CACHE.get(value);
+    if (cached) {
+        return cached;
+    }
+    const seed = toUtfBytes(value);
+    STATIC_SEED_CACHE.set(value, seed);
+    return seed;
+}
+function derivePda(seeds, programId) {
+    return PublicKey.findProgramAddressSync(seeds, programId);
+}
+function toSeedBytes(token, args) {
+    if (!token.includes(":")) {
+        return getStaticSeed(token);
+    }
+    const [field, encoding] = token.split(":");
+    const value = args[field];
+    invariant(value != null, `Missing PDA seed value for "${field}"`);
+    switch (encoding) {
+        case "pubkey":
+            invariant(value instanceof PublicKey, `PDA seed "${field}" must be a PublicKey`);
+            return value.toBytes();
+        case "u8":
+            invariant(typeof value === "number", `PDA seed "${field}" must be a number`);
+            return toU8Bytes(value);
+        case "u32":
+            invariant(typeof value === "number", `PDA seed "${field}" must be a number`);
+            return toU32Bytes(value);
+        case "u64":
+            invariant(typeof value === "bigint" || typeof value === "number", `PDA seed "${field}" must be a bigint or number`);
+            return toU64Bytes(typeof value === "bigint" ? value : BigInt(value));
+        case "u128":
+            invariant(typeof value === "bigint" || typeof value === "number", `PDA seed "${field}" must be a bigint or number`);
+            return toU128Bytes(typeof value === "bigint" ? value : BigInt(value));
+        default:
+            invariant(false, `Unsupported PDA seed encoding "${encoding}"`);
+    }
+}
+function derivePdaFromRegistry(key, args, programId) {
+    return derivePda(PDA_REGISTRY[key].seeds.map((seed) => toSeedBytes(seed, args)), programId);
+}
+export function getProgramConfigPda({ programId = PROGRAM_ID, }) {
+    return derivePdaFromRegistry("programConfig", {}, programId);
+}
+export function getSettingsPda({ accountIndex, programId = PROGRAM_ID, }) {
+    return derivePdaFromRegistry("settings", { accountIndex }, programId);
+}
+export function getSmartAccountPda({ settingsPda, accountIndex, programId = PROGRAM_ID, }) {
+    invariant(accountIndex >= 0 && accountIndex < 256, "Invalid vault index");
+    return derivePdaFromRegistry("smartAccount", { settingsPda, accountIndex }, programId);
+}
+export function getEphemeralSignerPda({ transactionPda, ephemeralSignerIndex, programId = PROGRAM_ID, }) {
+    return derivePdaFromRegistry("ephemeralSigner", { transactionPda, ephemeralSignerIndex }, programId);
+}
+export function getTransactionPda({ settingsPda, transactionIndex, programId = PROGRAM_ID, }) {
+    return derivePdaFromRegistry("transaction", { settingsPda, transactionIndex }, programId);
+}
+export function getProposalPda({ settingsPda, transactionIndex, programId = PROGRAM_ID, }) {
+    return derivePdaFromRegistry("proposal", { settingsPda, transactionIndex }, programId);
+}
+export function getBatchTransactionPda({ settingsPda, batchIndex, transactionIndex, programId = PROGRAM_ID, }) {
+    return derivePdaFromRegistry("batchTransaction", { settingsPda, batchIndex, transactionIndex }, programId);
+}
+export function getSpendingLimitPda({ settingsPda, seed, programId = PROGRAM_ID, }) {
+    return derivePdaFromRegistry("spendingLimit", { settingsPda, seed }, programId);
+}
+export function getTransactionBufferPda({ consensusPda, creator, bufferIndex, programId = PROGRAM_ID, }) {
+    return derivePdaFromRegistry("transactionBuffer", { consensusPda, creator, bufferIndex }, programId);
+}
+export function getPolicyPda({ settingsPda, policySeed, programId = PROGRAM_ID, }) {
+    return derivePdaFromRegistry("policy", { settingsPda, policySeed }, programId);
+}
+export { PDA_REGISTRY };

package/dist/src/core/spec/features.d.ts

@@ -0,0 +1 @@
+export * from "../../spec/features.js";

package/dist/src/core/spec/features.js

@@ -0,0 +1 @@
+export * from "../../spec/features.js";

package/dist/src/core/spec/idl.d.ts

@@ -0,0 +1 @@
+export * from "../../spec/idl.js";

package/dist/src/core/spec/idl.js

@@ -0,0 +1 @@
+export * from "../../spec/idl.js";

package/dist/src/core/spec/index.d.ts

@@ -0,0 +1,4 @@
+export * from "../../spec/features.js";
+export * from "../../spec/idl.js";
+export * from "../../spec/operation-registry.js";
+export * from "../../spec/pda-registry.js";

package/dist/src/core/spec/index.js

@@ -0,0 +1,4 @@
+export * from "../../spec/features.js";
+export * from "../../spec/idl.js";
+export * from "../../spec/operation-registry.js";
+export * from "../../spec/pda-registry.js";

package/dist/src/core/spec/pda-registry.d.ts

@@ -0,0 +1 @@
+export * from "../../spec/pda-registry.js";

package/dist/src/core/spec/pda-registry.js

@@ -0,0 +1 @@
+export * from "../../spec/pda-registry.js";

package/dist/src/core/transport/index.d.ts

@@ -0,0 +1,54 @@
+import { VersionedTransaction } from "@solana/web3.js";
+import type { AddressLookupTableAccount, Commitment, Connection, PublicKey, SendOptions, Signer, TransactionInstruction } from "@solana/web3.js";
+export type PreparedLoyalSmartAccountsOperation<Name extends string = string> = Readonly<{
+    operation: Name;
+    payer: PublicKey;
+    programId: PublicKey;
+    requiresConfirmation: boolean;
+    instructions: readonly TransactionInstruction[];
+    lookupTableAccounts: readonly AddressLookupTableAccount[];
+}>;
+export type LoyalSmartAccountsConfirmationContext = {
+    prepared: PreparedLoyalSmartAccountsOperation<string>;
+    blockhash: string;
+    lastValidBlockHeight: number;
+    commitment?: Commitment;
+};
+export type LoyalSmartAccountsSendPreparedContext = {
+    blockhash: string;
+    lastValidBlockHeight: number;
+    commitment?: Commitment;
+    sendOptions?: SendOptions;
+    compileUnsignedTransaction: () => VersionedTransaction;
+};
+export type LoyalSmartAccountsSendPreparedFn = (prepared: PreparedLoyalSmartAccountsOperation<string>, signers: readonly Signer[], context: LoyalSmartAccountsSendPreparedContext) => Promise<string>;
+export type LoyalSmartAccountsConfirmFn = (signature: string, context: LoyalSmartAccountsConfirmationContext) => Promise<void>;
+export type LoyalSmartAccountsClientConfig = {
+    connection: Connection;
+    programId?: PublicKey;
+    defaultCommitment?: Commitment;
+    sendPrepared?: LoyalSmartAccountsSendPreparedFn;
+    confirm?: LoyalSmartAccountsConfirmFn;
+};
+export type LoyalSmartAccountsTransport = {
+    connection: Connection;
+    programId: PublicKey;
+    defaultCommitment?: Commitment;
+    sendPrepared?: LoyalSmartAccountsSendPreparedFn;
+    confirm?: LoyalSmartAccountsConfirmFn;
+};
+export type LoyalSmartAccountsSendOptions = SendOptions;
+export type LoyalSmartAccountsConfirmBehavior = true | false | "if-required";
+export declare function createTransport(config: LoyalSmartAccountsClientConfig): LoyalSmartAccountsTransport;
+export declare function freezePreparedOperation<Name extends string>(operation: PreparedLoyalSmartAccountsOperation<Name>): PreparedLoyalSmartAccountsOperation<Name>;
+export declare function compilePreparedOperation(args: {
+    prepared: PreparedLoyalSmartAccountsOperation<string>;
+    blockhash: string;
+}): VersionedTransaction;
+export declare function sendPreparedOperation(args: {
+    transport: LoyalSmartAccountsTransport;
+    prepared: PreparedLoyalSmartAccountsOperation<string>;
+    signers: Signer[];
+    sendOptions?: LoyalSmartAccountsSendOptions;
+    confirm?: LoyalSmartAccountsConfirmBehavior;
+}): Promise<string>;

package/dist/src/core/transport/index.js

@@ -0,0 +1,96 @@
+import { TransactionMessage, VersionedTransaction } from "@solana/web3.js";
+import { PROGRAM_ID } from "../generated/index.js";
+import { translateAndThrowAnchorError } from "../errors/index.js";
+export function createTransport(config) {
+    return {
+        connection: config.connection,
+        programId: config.programId ?? PROGRAM_ID,
+        defaultCommitment: config.defaultCommitment,
+        sendPrepared: config.sendPrepared,
+        confirm: config.confirm,
+    };
+}
+export function freezePreparedOperation(operation) {
+    return Object.freeze({
+        ...operation,
+        instructions: Object.freeze([...operation.instructions]),
+        lookupTableAccounts: Object.freeze([
+            ...(operation.lookupTableAccounts ?? []),
+        ]),
+    });
+}
+function dedupeSigners(signers) {
+    const unique = new Map();
+    for (const signer of signers) {
+        unique.set(signer.publicKey.toBase58(), signer);
+    }
+    return [...unique.values()];
+}
+async function confirmPreparedOperation(args) {
+    const context = {
+        prepared: args.prepared,
+        blockhash: args.blockhash,
+        lastValidBlockHeight: args.lastValidBlockHeight,
+        commitment: args.transport.defaultCommitment,
+    };
+    if (args.transport.confirm) {
+        await args.transport.confirm(args.signature, context);
+        return;
+    }
+    const confirmation = await args.transport.connection.confirmTransaction({
+        signature: args.signature,
+        blockhash: args.blockhash,
+        lastValidBlockHeight: args.lastValidBlockHeight,
+    }, args.transport.defaultCommitment);
+    if (confirmation.value.err) {
+        throw new Error(`Transaction ${args.signature} failed to confirm: ${JSON.stringify(confirmation.value.err)}`);
+    }
+}
+export function compilePreparedOperation(args) {
+    const message = new TransactionMessage({
+        payerKey: args.prepared.payer,
+        recentBlockhash: args.blockhash,
+        instructions: [...args.prepared.instructions],
+    }).compileToV0Message([...args.prepared.lookupTableAccounts]);
+    return new VersionedTransaction(message);
+}
+export async function sendPreparedOperation(args) {
+    const { transport, prepared, sendOptions } = args;
+    const signers = dedupeSigners(args.signers);
+    const latestBlockhash = await transport.connection.getLatestBlockhash(transport.defaultCommitment);
+    try {
+        const compileUnsignedTransaction = () => compilePreparedOperation({
+            prepared,
+            blockhash: latestBlockhash.blockhash,
+        });
+        const signature = transport.sendPrepared
+            ? await transport.sendPrepared(prepared, signers, {
+                blockhash: latestBlockhash.blockhash,
+                lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
+                commitment: transport.defaultCommitment,
+                sendOptions,
+                compileUnsignedTransaction,
+            })
+            : await (async () => {
+                const transaction = compileUnsignedTransaction();
+                transaction.sign(signers);
+                return transport.connection.sendTransaction(transaction, sendOptions);
+            })();
+        const shouldConfirm = args.confirm === true ||
+            (args.confirm !== false && prepared.requiresConfirmation);
+        if (shouldConfirm) {
+            await confirmPreparedOperation({
+                transport,
+                prepared,
+                signature,
+                blockhash: latestBlockhash.blockhash,
+                lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
+            });
+        }
+        return signature;
+    }
+    catch (error) {
+        translateAndThrowAnchorError(error);
+        throw error;
+    }
+}

package/dist/src/errors.d.ts

@@ -0,0 +1 @@
+export * from "./core/errors/index.js";

package/dist/src/errors.js

@@ -0,0 +1 @@
+export * from "./core/errors/index.js";