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

package/dist/src/utils.d.ts

@@ -0,0 +1,61 @@
+import { bignum } from "@metaplex-foundation/beet";
+import { AccountMeta, AddressLookupTableAccount, Connection, MessageV0, PublicKey, TransactionInstruction, TransactionMessage, VersionedTransaction } from "@solana/web3.js";
+import { SmartAccountTransactionMessage } from "./generated";
+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;
+export declare function getAvailableMemoSize(txWithoutMemo: VersionedTransaction): number;
+export declare function isStaticWritableIndex(message: SmartAccountTransactionMessage, index: number): boolean;
+export declare function isSignerIndex(message: SmartAccountTransactionMessage, index: number): boolean;
+/** We use custom serialization for `transaction_message` that ensures as small byte size as possible. */
+export declare function transactionMessageToMultisigTransactionMessageBytes({ message, addressLookupTableAccounts, smartAccountPda, }: {
+    message: TransactionMessage;
+    addressLookupTableAccounts?: AddressLookupTableAccount[];
+    smartAccountPda: PublicKey;
+}): {
+    transactionMessageBytes: Uint8Array;
+    compiledMessage: MessageV0;
+};
+export declare function instructionsToSynchronousTransactionDetails({ vaultPda, members, transaction_instructions, }: {
+    vaultPda: PublicKey;
+    members: PublicKey[];
+    transaction_instructions: TransactionInstruction[];
+}): {
+    instructions: Uint8Array;
+    accounts: AccountMeta[];
+};
+export declare function instructionsToSynchronousTransactionDetailsV2({ vaultPda, members, transaction_instructions, }: {
+    vaultPda: PublicKey;
+    members: PublicKey[];
+    transaction_instructions: TransactionInstruction[];
+}): {
+    instructions: Uint8Array;
+    accounts: AccountMeta[];
+};
+export declare function instructionsToSynchronousTransactionDetailsV2WithHooks({ vaultPda, members, preHookAccounts, postHookAccounts, transaction_instructions, }: {
+    vaultPda: PublicKey;
+    members: PublicKey[];
+    preHookAccounts: AccountMeta[];
+    postHookAccounts: AccountMeta[];
+    transaction_instructions: TransactionInstruction[];
+}): {
+    instructions: Uint8Array;
+    accounts: AccountMeta[];
+};
+/** Populate remaining accounts required for execution of the transaction. */
+export declare function accountsForTransactionExecute({ connection, transactionPda, smartAccountPda, message, ephemeralSignerBumps, programId, }: {
+    connection: Connection;
+    message: SmartAccountTransactionMessage;
+    ephemeralSignerBumps: number[];
+    smartAccountPda: PublicKey;
+    transactionPda: PublicKey;
+    programId?: PublicKey;
+}): Promise<{
+    /** Account metas used in the `message`. */
+    accountMetas: AccountMeta[];
+    /** Address lookup table accounts used in the `message`. */
+    lookupTableAccounts: AddressLookupTableAccount[];
+}>;

package/dist/src/utils.js

@@ -0,0 +1,217 @@
+import { u32, u64, u8, u128 } from "@metaplex-foundation/beet";
+import { Buffer } from "buffer";
+import invariant from "invariant";
+import { MissingLookupTableAccountError } from "./errors";
+import { getEphemeralSignerPda } from "./pda";
+import { transactionMessageBeet } from "./types";
+import { compileToSynchronousMessageAndAccounts } from "./utils/compileToSynchronousMessage";
+import { compileToWrappedMessageV0 } from "./utils/compileToWrappedMessageV0";
+import { compileToSynchronousMessageAndAccountsV2, compileToSynchronousMessageAndAccountsV2WithHooks, } from "./utils/compileToSynchronousMessageV2";
+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());
+}
+const MAX_TX_SIZE_BYTES = 1232;
+const STRING_LEN_SIZE = 4;
+export function getAvailableMemoSize(txWithoutMemo) {
+    const txSize = txWithoutMemo.serialize().length;
+    return (MAX_TX_SIZE_BYTES -
+        txSize -
+        STRING_LEN_SIZE -
+        // Sometimes long memo can trigger switching from 1 to 2 bytes length encoding in Compact-u16,
+        // so we reserve 1 extra byte to make sure.
+        1);
+}
+export function isStaticWritableIndex(message, index) {
+    const numAccountKeys = message.accountKeys.length;
+    const { numSigners, numWritableSigners, numWritableNonSigners } = message;
+    if (index >= numAccountKeys) {
+        // `index` is not a part of static `accountKeys`.
+        return false;
+    }
+    if (index < numWritableSigners) {
+        // `index` is within the range of writable signer keys.
+        return true;
+    }
+    if (index >= numSigners) {
+        // `index` is within the range of non-signer keys.
+        const indexIntoNonSigners = index - numSigners;
+        // Whether `index` is within the range of writable non-signer keys.
+        return indexIntoNonSigners < numWritableNonSigners;
+    }
+    return false;
+}
+export function isSignerIndex(message, index) {
+    return index < message.numSigners;
+}
+/** We use custom serialization for `transaction_message` that ensures as small byte size as possible. */
+export function transactionMessageToMultisigTransactionMessageBytes({ message, addressLookupTableAccounts, smartAccountPda, }) {
+    // // Make sure authority is marked as non-signer in all instructions,
+    // // otherwise the message will be serialized in incorrect format.
+    // message.instructions.forEach((instruction) => {
+    //   instruction.keys.forEach((key) => {
+    //     if (key.pubkey.equals(vaultPda)) {
+    //       key.isSigner = false;
+    //     }
+    //   });
+    // });
+    // Use custom implementation of `message.compileToV0Message` that allows instruction programIds
+    // to also be loaded from `addressLookupTableAccounts`.
+    const compiledMessage = compileToWrappedMessageV0({
+        payerKey: message.payerKey,
+        recentBlockhash: message.recentBlockhash,
+        instructions: message.instructions,
+        addressLookupTableAccounts,
+    });
+    // const compiledMessage = message.compileToV0Message(
+    //   addressLookupTableAccounts
+    // );
+    // We use custom serialization for `transaction_message` that ensures as small byte size as possible.
+    const [transactionMessageBytes] = transactionMessageBeet.serialize({
+        numSigners: compiledMessage.header.numRequiredSignatures,
+        numWritableSigners: compiledMessage.header.numRequiredSignatures -
+            compiledMessage.header.numReadonlySignedAccounts,
+        numWritableNonSigners: compiledMessage.staticAccountKeys.length -
+            compiledMessage.header.numRequiredSignatures -
+            compiledMessage.header.numReadonlyUnsignedAccounts,
+        accountKeys: compiledMessage.staticAccountKeys,
+        instructions: compiledMessage.compiledInstructions.map((ix) => {
+            return {
+                programIdIndex: ix.programIdIndex,
+                accountIndexes: ix.accountKeyIndexes,
+                data: Array.from(ix.data),
+            };
+        }),
+        addressTableLookups: compiledMessage.addressTableLookups,
+    });
+    return {
+        transactionMessageBytes,
+        compiledMessage,
+    };
+}
+export function instructionsToSynchronousTransactionDetails({ vaultPda, members, transaction_instructions, }) {
+    const { instructions, accounts } = compileToSynchronousMessageAndAccounts({
+        vaultPda,
+        members,
+        instructions: transaction_instructions,
+    });
+    return {
+        instructions,
+        accounts,
+    };
+}
+export function instructionsToSynchronousTransactionDetailsV2({ vaultPda, members, transaction_instructions, }) {
+    const { instructions, accounts } = compileToSynchronousMessageAndAccountsV2({
+        vaultPda,
+        members,
+        instructions: transaction_instructions,
+    });
+    return {
+        instructions,
+        accounts,
+    };
+}
+export function instructionsToSynchronousTransactionDetailsV2WithHooks({ vaultPda, members, preHookAccounts, postHookAccounts, transaction_instructions, }) {
+    const { instructions, accounts } = compileToSynchronousMessageAndAccountsV2WithHooks({
+        vaultPda,
+        members,
+        preHookAccounts,
+        postHookAccounts,
+        instructions: transaction_instructions,
+    });
+    return {
+        instructions,
+        accounts,
+    };
+}
+/** Populate remaining accounts required for execution of the transaction. */
+export async function accountsForTransactionExecute({ connection, transactionPda, smartAccountPda, message, ephemeralSignerBumps, programId, }) {
+    const ephemeralSignerPdas = ephemeralSignerBumps.map((_, additionalSignerIndex) => {
+        return getEphemeralSignerPda({
+            transactionPda,
+            ephemeralSignerIndex: additionalSignerIndex,
+            programId,
+        })[0];
+    });
+    const addressLookupTableKeySet = new Map();
+    for (const { accountKey } of message.addressTableLookups) {
+        addressLookupTableKeySet.set(accountKey.toBase58(), accountKey);
+    }
+    const addressLookupTableKeys = [...addressLookupTableKeySet.values()];
+    const addressLookupTableAccounts = new Map(await Promise.all(addressLookupTableKeys.map(async (key) => {
+        const { value } = await connection.getAddressLookupTable(key);
+        if (!value) {
+            throw new MissingLookupTableAccountError(key.toBase58());
+        }
+        return [key.toBase58(), value];
+    })));
+    // Populate account metas required for execution of the transaction.
+    const accountMetas = [];
+    // First add the lookup table accounts used by the transaction. They are needed for on-chain validation.
+    accountMetas.push(...addressLookupTableKeys.map((key) => {
+        return { pubkey: key, isSigner: false, isWritable: false };
+    }));
+    // Then add static account keys included into the message.
+    for (const [accountIndex, accountKey] of message.accountKeys.entries()) {
+        accountMetas.push({
+            pubkey: accountKey,
+            isWritable: isStaticWritableIndex(message, accountIndex),
+            // NOTE: vaultPda and ephemeralSignerPdas cannot be marked as signers,
+            // because they are PDAs and hence won't have their signatures on the transaction.
+            isSigner: isSignerIndex(message, accountIndex) &&
+                !accountKey.equals(smartAccountPda) &&
+                !ephemeralSignerPdas.find((k) => accountKey.equals(k)),
+        });
+    }
+    // Then add accounts that will be loaded with address lookup tables.
+    for (const lookup of message.addressTableLookups) {
+        const lookupTableAccount = addressLookupTableAccounts.get(lookup.accountKey.toBase58());
+        invariant(lookupTableAccount, new MissingLookupTableAccountError(lookup.accountKey.toBase58()).message);
+        for (const accountIndex of lookup.writableIndexes) {
+            const pubkey = lookupTableAccount.state.addresses[accountIndex];
+            invariant(pubkey, new MissingLookupTableAccountError(lookup.accountKey.toBase58(), `does not contain address at index ${accountIndex}.`).message);
+            accountMetas.push({
+                pubkey,
+                isWritable: true,
+                // Accounts in address lookup tables can not be signers.
+                isSigner: false,
+            });
+        }
+        for (const accountIndex of lookup.readonlyIndexes) {
+            const pubkey = lookupTableAccount.state.addresses[accountIndex];
+            invariant(pubkey, new MissingLookupTableAccountError(lookup.accountKey.toBase58(), `does not contain address at index ${accountIndex}.`).message);
+            accountMetas.push({
+                pubkey,
+                isWritable: false,
+                // Accounts in address lookup tables can not be signers.
+                isSigner: false,
+            });
+        }
+    }
+    return {
+        accountMetas,
+        lookupTableAccounts: [...addressLookupTableAccounts.values()],
+    };
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@loyal-labs/loyal-smart-accounts-core",
+  "version": "0.1.1",
+  "description": "Core artifacts and low-level builders for the Loyal smart accounts SDK",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./loyal": {
+      "import": "./dist/loyal.js",
+      "types": "./dist/loyal.d.ts"
+    },
+    "./internal": {
+      "import": "./dist/internal.js",
+      "types": "./dist/internal.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "upstream"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "bun run clean && tsc -p tsconfig.build.json",
+    "prepublishOnly": "bun run build",
+    "clean": "rm -rf dist",
+    "test": "bun test"
+  },
+  "author": "Loyal",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/loyal-labs/loyal-app.git",
+    "directory": "sdk/loyal-smart-accounts-core"
+  },
+  "peerDependencies": {
+    "@solana/web3.js": "^1.98.0"
+  },
+  "dependencies": {
+    "@loyal-labs/solana-rpc": "^0.1.1",
+    "@metaplex-foundation/beet": "0.7.1",
+    "@metaplex-foundation/beet-solana": "0.4.0",
+    "@metaplex-foundation/cusper": "^0.0.2",
+    "@solana/spl-token": "^0.4.13",
+    "assert": "^2.1.0",
+    "bn.js": "^5.2.2",
+    "buffer": "^6.0.3",
+    "invariant": "^2.2.4"
+  },
+  "devDependencies": {
+    "@types/bn.js": "^5.1.6",
+    "@types/bun": "latest",
+    "@types/invariant": "^2.2.37",
+    "@types/node": "^24.0.15",
+    "typescript": "^5.7.3"
+  },
+  "peerDependenciesMeta": {
+    "@solana/web3.js": {
+      "optional": false
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/upstream/manifest.json

@@ -0,0 +1,14 @@
+{
+  "repoUrl": "https://github.com/Squads-Protocol/smart-account-program",
+  "commitSha": "80bf1f7ad28fd1176c364879776982730b8e9c80",
+  "fetchedAt": "2026-03-20",
+  "sourceIdlPath": "sdk/smart-account/idl/squads_smart_account_program.json",
+  "sourceProgramLibPath": "programs/squads_smart_account_program/src/lib.rs",
+  "sourceSolitaConfigPath": "sdk/smart-account/.solitarc.js",
+  "normalizedIdlPath": "upstream/normalized/squads_smart_account_program.json",
+  "generatedFromNormalizedIdl": true,
+  "generator": "@metaplex-foundation/solita@0.20.0",
+  "programId": "SMRTzfY6DfH5ik3TKiyLFfXexV8uSG3d2UksSCYdunG",
+  "upstreamPackageName": "@sqds/smart-account",
+  "upstreamPackageVersion": "2.1.2"
+}