@loyal-labs/loyal-smart-accounts 0.1.1

package/README.md

@@ -0,0 +1,114 @@
+# @loyal-labs/loyal-smart-accounts
+
+Universal TypeScript SDK for the Squads Smart Account program, packaged for Loyal's monorepo and applications.
+
+This package does not depend on Squads' unpublished npm package. Loyal owns:
+
+- a pinned upstream snapshot in `@loyal-labs/loyal-smart-accounts-core`
+- a Loyal-normalized IDL and generated low-level artifacts
+- a vertical-slice SDK with explicit `instructions`, `prepare`, `queries`, and client send flows
+- an optional Loyal env adapter at `@loyal-labs/loyal-smart-accounts-core/loyal`
+
+The public SDK exposes:
+
+- `generated` for low-level generated accounts, instructions, types, and errors
+- `programConfig`
+- `smartAccounts`
+- `proposals`
+- `transactions`
+- `batches`
+- `policies`
+- `spendingLimits`
+- `execution`
+- `pda`, `codecs`, and `errors` for shared protocol helpers
+
+## Installation
+
+```bash
+bun add @loyal-labs/loyal-smart-accounts @solana/web3.js
+# or
+npm install @loyal-labs/loyal-smart-accounts @solana/web3.js
+```
+
+## Quick Start
+
+```ts
+import {
+  createLoyalSmartAccountsClient,
+  smartAccounts,
+  pda,
+  codecs,
+} from "@loyal-labs/loyal-smart-accounts";
+import { Connection, Keypair } from "@solana/web3.js";
+
+const connection = new Connection("https://api.devnet.solana.com");
+const creator = Keypair.generate();
+
+const [settingsPda] = pda.getSettingsPda({
+  accountIndex: 1n,
+});
+
+const instruction = smartAccounts.instructions.create({
+  treasury: creator.publicKey,
+  creator: creator.publicKey,
+  settings: settingsPda,
+  settingsAuthority: null,
+  threshold: 1,
+  signers: [
+    {
+      key: creator.publicKey,
+      permissions: codecs.Permissions.all(),
+    },
+  ],
+  timeLock: 0,
+  rentCollector: null,
+});
+
+const prepared = await smartAccounts.prepare.create({
+  treasury: creator.publicKey,
+  creator: creator.publicKey,
+  settings: settingsPda,
+  settingsAuthority: null,
+  threshold: 1,
+  signers: [
+    {
+      key: creator.publicKey,
+      permissions: codecs.Permissions.all(),
+    },
+  ],
+  timeLock: 0,
+  rentCollector: null,
+});
+
+const client = createLoyalSmartAccountsClient({ connection });
+
+await client.send(prepared, {
+  signers: [creator],
+});
+
+await client.smartAccounts.create({
+  treasury: creator.publicKey,
+  creator,
+  settings: settingsPda,
+  settingsAuthority: null,
+  threshold: 1,
+  signers: [
+    {
+      key: creator.publicKey,
+      permissions: codecs.Permissions.all(),
+    },
+  ],
+  timeLock: 0,
+  rentCollector: null,
+});
+```
+
+## Upstream Sync
+
+To refresh the pinned upstream snapshot and synced generated artifacts:
+
+```bash
+bun run loyal-smart-accounts:update
+```
+
+The update script stores the fetched upstream commit and IDL snapshots in the core package, validates registry coverage, and refreshes committed generated artifacts.

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/src/client.d.ts

@@ -0,0 +1,39 @@
+import type { Signer } from "@solana/web3.js";
+import { type LoyalSmartAccountsConfirmBehavior, type LoyalSmartAccountsClientConfig, type LoyalSmartAccountsSendOptions, type PreparedLoyalSmartAccountsOperation } from "@loyal-labs/loyal-smart-accounts-core";
+import { createProgramConfigClient, programConfig } from "./features/program-config/index.js";
+import { createSmartAccountsClient, smartAccounts } from "./features/smart-accounts/index.js";
+import { createProposalsClient, proposals } from "./features/proposals/index.js";
+import { createTransactionsClient, transactions } from "./features/transactions/index.js";
+import { batches, createBatchesClient } from "./features/batches/index.js";
+import { policies, createPoliciesClient } from "./features/policies/index.js";
+import { createSpendingLimitsClient, spendingLimits } from "./features/spending-limits/index.js";
+import { createExecutionClient, execution } from "./features/execution/index.js";
+export type { LoyalSmartAccountsConfirmBehavior, LoyalSmartAccountsClientConfig, LoyalSmartAccountsSendOptions, PreparedLoyalSmartAccountsOperation, } from "@loyal-labs/loyal-smart-accounts-core";
+export type LoyalSmartAccountsClient = {
+    connection: LoyalSmartAccountsClientConfig["connection"];
+    programId: Exclude<LoyalSmartAccountsClientConfig["programId"], undefined>;
+    send: (prepared: PreparedLoyalSmartAccountsOperation<string>, args: {
+        signers: Signer[];
+        sendOptions?: LoyalSmartAccountsSendOptions;
+        confirm?: LoyalSmartAccountsConfirmBehavior;
+    }) => Promise<string>;
+    programConfig: ReturnType<typeof createProgramConfigClient>;
+    smartAccounts: ReturnType<typeof createSmartAccountsClient>;
+    proposals: ReturnType<typeof createProposalsClient>;
+    transactions: ReturnType<typeof createTransactionsClient>;
+    batches: ReturnType<typeof createBatchesClient>;
+    policies: ReturnType<typeof createPoliciesClient>;
+    spendingLimits: ReturnType<typeof createSpendingLimitsClient>;
+    execution: ReturnType<typeof createExecutionClient>;
+    features: {
+        programConfig: typeof programConfig;
+        smartAccounts: typeof smartAccounts;
+        proposals: typeof proposals;
+        transactions: typeof transactions;
+        batches: typeof batches;
+        policies: typeof policies;
+        spendingLimits: typeof spendingLimits;
+        execution: typeof execution;
+    };
+};
+export declare function createLoyalSmartAccountsClient(config: LoyalSmartAccountsClientConfig): LoyalSmartAccountsClient;

package/dist/src/client.js

@@ -0,0 +1,43 @@
+import { createTransport, sendPreparedOperation, } from "@loyal-labs/loyal-smart-accounts-core";
+import { createProgramConfigClient, programConfig, } from "./features/program-config/index.js";
+import { createSmartAccountsClient, smartAccounts, } from "./features/smart-accounts/index.js";
+import { createProposalsClient, proposals, } from "./features/proposals/index.js";
+import { createTransactionsClient, transactions, } from "./features/transactions/index.js";
+import { batches, createBatchesClient } from "./features/batches/index.js";
+import { policies, createPoliciesClient } from "./features/policies/index.js";
+import { createSpendingLimitsClient, spendingLimits, } from "./features/spending-limits/index.js";
+import { createExecutionClient, execution, } from "./features/execution/index.js";
+export function createLoyalSmartAccountsClient(config) {
+    const transport = createTransport(config);
+    return {
+        connection: transport.connection,
+        programId: transport.programId,
+        send(prepared, args) {
+            return sendPreparedOperation({
+                transport,
+                prepared,
+                signers: [...args.signers],
+                sendOptions: args.sendOptions,
+                confirm: args.confirm,
+            });
+        },
+        programConfig: createProgramConfigClient(transport),
+        smartAccounts: createSmartAccountsClient(transport),
+        proposals: createProposalsClient(transport),
+        transactions: createTransactionsClient(transport),
+        batches: createBatchesClient(transport),
+        policies: createPoliciesClient(transport),
+        spendingLimits: createSpendingLimitsClient(transport),
+        execution: createExecutionClient(transport),
+        features: {
+            programConfig,
+            smartAccounts,
+            proposals,
+            transactions,
+            batches,
+            policies,
+            spendingLimits,
+            execution,
+        },
+    };
+}

package/dist/src/feature-factory.d.ts

@@ -0,0 +1,52 @@
+import type { Commitment, Connection, GetAccountInfoConfig, PublicKey } from "@solana/web3.js";
+import type { LoyalSmartAccountsTransport } from "@loyal-labs/loyal-smart-accounts-core";
+import type { LoyalSmartAccountsFeatureName, RuntimeOperationsForFeature } from "./operation-registry.js";
+type QueryFunction = (connection: Connection, ...args: any[]) => Promise<unknown>;
+type QueryFactories = Record<string, QueryFunction>;
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type InstructionsApi<Operations> = {
+    [K in keyof Operations as Operations[K] extends {
+        instruction: (...args: never[]) => unknown;
+    } ? K : never]: Operations[K] extends {
+        instruction: infer T;
+    } ? T : never;
+};
+type PrepareApi<Operations> = {
+    [K in keyof Operations]: Operations[K] extends {
+        prepare: infer T;
+    } ? T : never;
+};
+type BoundPrepareApi<Operations> = {
+    [K in keyof Operations]: Operations[K] extends {
+        boundPrepare: infer T;
+    } ? T : never;
+};
+type ClientMethodApi<Operations> = {
+    [K in keyof Operations]: Operations[K] extends {
+        client: infer T;
+    } ? T : never;
+};
+type FeatureModule<Operations extends Record<string, unknown>, Accounts extends Record<string, unknown>, Queries extends QueryFactories> = {
+    accounts: Accounts;
+    instructions: InstructionsApi<Operations>;
+    prepare: PrepareApi<Operations>;
+    queries: Queries;
+    client: (transport: LoyalSmartAccountsTransport) => Simplify<ClientMethodApi<Operations> & {
+        prepare: BoundPrepareApi<Operations>;
+        queries: {
+            [K in keyof Queries]: Queries[K] extends (connection: Connection, ...args: infer Rest) => infer Result ? (...args: Rest) => Result : never;
+        };
+    }>;
+};
+export declare function createAccountFetcher<T>(accountClass: {
+    fromAccountAddress(connection: Connection, address: PublicKey, commitmentOrConfig?: Commitment | GetAccountInfoConfig): Promise<T>;
+}): (connection: Connection, address: PublicKey, commitmentOrConfig?: Commitment | GetAccountInfoConfig) => Promise<T>;
+export declare function createFeatureModule<Feature extends LoyalSmartAccountsFeatureName, Operations extends RuntimeOperationsForFeature<Feature>, Accounts extends Record<string, unknown>, Queries extends QueryFactories>(args: {
+    feature: Feature;
+    accounts: Accounts;
+    operations: Operations;
+    queries: Queries;
+}): FeatureModule<Operations, Accounts, Queries>;
+export type { FeatureModule };

package/dist/src/feature-factory.js

@@ -0,0 +1,33 @@
+export function createAccountFetcher(accountClass) {
+    return (connection, address, commitmentOrConfig) => accountClass.fromAccountAddress(connection, address, commitmentOrConfig);
+}
+function bindQueries(queries, connection) {
+    return Object.fromEntries(Object.entries(queries).map(([name, query]) => [
+        name,
+        (...args) => query(connection, ...args),
+    ]));
+}
+export function createFeatureModule(args) {
+    const operationEntries = Object.entries(args.operations);
+    const instructions = Object.fromEntries(operationEntries
+        .filter(([, operation]) => typeof operation.instruction === "function")
+        .map(([name, operation]) => [name, operation.instruction]));
+    const prepare = Object.fromEntries(operationEntries.map(([name, operation]) => [name, operation.prepare]));
+    return {
+        accounts: args.accounts,
+        instructions,
+        prepare,
+        queries: args.queries,
+        client: (transport) => ({
+            ...Object.fromEntries(operationEntries.map(([name, operation]) => [
+                name,
+                (clientArgs) => operation.client(transport, clientArgs),
+            ])),
+            prepare: Object.fromEntries(operationEntries.map(([name, operation]) => [
+                name,
+                (prepareArgs) => operation.boundPrepare(transport, prepareArgs),
+            ])),
+            queries: bindQueries(args.queries, transport.connection),
+        }),
+    };
+}

package/dist/src/features/batches/index.d.ts

@@ -0,0 +1,10 @@
+import { Batch, BatchTransaction } from "@loyal-labs/loyal-smart-accounts-core";
+export declare const batches: import("../../feature-factory.js").FeatureModule<import("../../operation-registry.js").RuntimeOperationsForFeature<"batches">, {
+    Batch: typeof Batch;
+    BatchTransaction: typeof BatchTransaction;
+}, {
+    fetchBatch: (connection: import("@solana/web3.js").Connection, address: import("@solana/web3.js").PublicKey, commitmentOrConfig?: import("@solana/web3.js").Commitment | import("@solana/web3.js").GetAccountInfoConfig) => Promise<Batch>;
+    fetchBatchTransaction: (connection: import("@solana/web3.js").Connection, address: import("@solana/web3.js").PublicKey, commitmentOrConfig?: import("@solana/web3.js").Commitment | import("@solana/web3.js").GetAccountInfoConfig) => Promise<BatchTransaction>;
+}>;
+export type BatchesFeature = typeof batches;
+export declare const createBatchesClient: BatchesFeature["client"];

package/dist/src/features/batches/index.js

@@ -0,0 +1,16 @@
+import { Batch, BatchTransaction } from "@loyal-labs/loyal-smart-accounts-core";
+import { createAccountFetcher, createFeatureModule } from "../../feature-factory.js";
+import { getRuntimeOperationsForFeature } from "../../operation-registry.js";
+export const batches = createFeatureModule({
+    feature: "batches",
+    accounts: {
+        Batch,
+        BatchTransaction,
+    },
+    operations: getRuntimeOperationsForFeature("batches"),
+    queries: {
+        fetchBatch: createAccountFetcher(Batch),
+        fetchBatchTransaction: createAccountFetcher(BatchTransaction),
+    },
+});
+export const createBatchesClient = batches.client;

package/dist/src/features/execution/index.d.ts

@@ -0,0 +1,16 @@
+import { Batch, BatchTransaction, Policy, SettingsTransaction, Transaction } from "@loyal-labs/loyal-smart-accounts-core";
+export declare const execution: import("../../feature-factory.js").FeatureModule<import("../../operation-registry.js").RuntimeOperationsForFeature<"execution">, {
+    Batch: typeof Batch;
+    BatchTransaction: typeof BatchTransaction;
+    Policy: typeof Policy;
+    SettingsTransaction: typeof SettingsTransaction;
+    Transaction: typeof Transaction;
+}, {
+    fetchBatch: (connection: import("@solana/web3.js").Connection, address: import("@solana/web3.js").PublicKey, commitmentOrConfig?: import("@solana/web3.js").Commitment | import("@solana/web3.js").GetAccountInfoConfig) => Promise<Batch>;
+    fetchBatchTransaction: (connection: import("@solana/web3.js").Connection, address: import("@solana/web3.js").PublicKey, commitmentOrConfig?: import("@solana/web3.js").Commitment | import("@solana/web3.js").GetAccountInfoConfig) => Promise<BatchTransaction>;
+    fetchPolicy: (connection: import("@solana/web3.js").Connection, address: import("@solana/web3.js").PublicKey, commitmentOrConfig?: import("@solana/web3.js").Commitment | import("@solana/web3.js").GetAccountInfoConfig) => Promise<Policy>;
+    fetchSettingsTransaction: (connection: import("@solana/web3.js").Connection, address: import("@solana/web3.js").PublicKey, commitmentOrConfig?: import("@solana/web3.js").Commitment | import("@solana/web3.js").GetAccountInfoConfig) => Promise<SettingsTransaction>;
+    fetchTransaction: (connection: import("@solana/web3.js").Connection, address: import("@solana/web3.js").PublicKey, commitmentOrConfig?: import("@solana/web3.js").Commitment | import("@solana/web3.js").GetAccountInfoConfig) => Promise<Transaction>;
+}>;
+export type ExecutionFeature = typeof execution;
+export declare const createExecutionClient: ExecutionFeature["client"];

package/dist/src/features/execution/index.js

@@ -0,0 +1,22 @@
+import { Batch, BatchTransaction, Policy, SettingsTransaction, Transaction, } from "@loyal-labs/loyal-smart-accounts-core";
+import { createAccountFetcher, createFeatureModule } from "../../feature-factory.js";
+import { getRuntimeOperationsForFeature } from "../../operation-registry.js";
+export const execution = createFeatureModule({
+    feature: "execution",
+    accounts: {
+        Batch,
+        BatchTransaction,
+        Policy,
+        SettingsTransaction,
+        Transaction,
+    },
+    operations: getRuntimeOperationsForFeature("execution"),
+    queries: {
+        fetchBatch: createAccountFetcher(Batch),
+        fetchBatchTransaction: createAccountFetcher(BatchTransaction),
+        fetchPolicy: createAccountFetcher(Policy),
+        fetchSettingsTransaction: createAccountFetcher(SettingsTransaction),
+        fetchTransaction: createAccountFetcher(Transaction),
+    },
+});
+export const createExecutionClient = execution.client;

package/dist/src/features/policies/index.d.ts

@@ -0,0 +1,8 @@
+import { Policy } from "@loyal-labs/loyal-smart-accounts-core";
+export declare const policies: import("../../feature-factory.js").FeatureModule<import("../../operation-registry.js").RuntimeOperationsForFeature<"policies">, {
+    Policy: typeof Policy;
+}, {
+    fetchPolicy: (connection: import("@solana/web3.js").Connection, address: import("@solana/web3.js").PublicKey, commitmentOrConfig?: import("@solana/web3.js").Commitment | import("@solana/web3.js").GetAccountInfoConfig) => Promise<Policy>;
+}>;
+export type PoliciesFeature = typeof policies;
+export declare const createPoliciesClient: PoliciesFeature["client"];

package/dist/src/features/policies/index.js

@@ -0,0 +1,14 @@
+import { Policy } from "@loyal-labs/loyal-smart-accounts-core";
+import { createAccountFetcher, createFeatureModule } from "../../feature-factory.js";
+import { getRuntimeOperationsForFeature } from "../../operation-registry.js";
+export const policies = createFeatureModule({
+    feature: "policies",
+    accounts: {
+        Policy,
+    },
+    operations: getRuntimeOperationsForFeature("policies"),
+    queries: {
+        fetchPolicy: createAccountFetcher(Policy),
+    },
+});
+export const createPoliciesClient = policies.client;

package/dist/src/features/program-config/index.d.ts

@@ -0,0 +1,8 @@
+import { ProgramConfig } from "@loyal-labs/loyal-smart-accounts-core";
+export declare const programConfig: import("../../feature-factory.js").FeatureModule<import("../../operation-registry.js").RuntimeOperationsForFeature<"programConfig">, {
+    ProgramConfig: typeof ProgramConfig;
+}, {
+    fetchProgramConfig: (connection: import("@solana/web3.js").Connection, address: import("@solana/web3.js").PublicKey, commitmentOrConfig?: import("@solana/web3.js").Commitment | import("@solana/web3.js").GetAccountInfoConfig) => Promise<ProgramConfig>;
+}>;
+export type ProgramConfigFeature = typeof programConfig;
+export declare const createProgramConfigClient: ProgramConfigFeature["client"];

package/dist/src/features/program-config/index.js

@@ -0,0 +1,14 @@
+import { ProgramConfig } from "@loyal-labs/loyal-smart-accounts-core";
+import { createAccountFetcher, createFeatureModule } from "../../feature-factory.js";
+import { getRuntimeOperationsForFeature } from "../../operation-registry.js";
+export const programConfig = createFeatureModule({
+    feature: "programConfig",
+    accounts: {
+        ProgramConfig,
+    },
+    operations: getRuntimeOperationsForFeature("programConfig"),
+    queries: {
+        fetchProgramConfig: createAccountFetcher(ProgramConfig),
+    },
+});
+export const createProgramConfigClient = programConfig.client;

package/dist/src/features/proposals/index.d.ts

@@ -0,0 +1,8 @@
+import { Proposal } from "@loyal-labs/loyal-smart-accounts-core";
+export declare const proposals: import("../../feature-factory.js").FeatureModule<import("../../operation-registry.js").RuntimeOperationsForFeature<"proposals">, {
+    Proposal: typeof Proposal;
+}, {
+    fetchProposal: (connection: import("@solana/web3.js").Connection, address: import("@solana/web3.js").PublicKey, commitmentOrConfig?: import("@solana/web3.js").Commitment | import("@solana/web3.js").GetAccountInfoConfig) => Promise<Proposal>;
+}>;
+export type ProposalsFeature = typeof proposals;
+export declare const createProposalsClient: ProposalsFeature["client"];

package/dist/src/features/proposals/index.js

@@ -0,0 +1,14 @@
+import { Proposal } from "@loyal-labs/loyal-smart-accounts-core";
+import { createAccountFetcher, createFeatureModule } from "../../feature-factory.js";
+import { getRuntimeOperationsForFeature } from "../../operation-registry.js";
+export const proposals = createFeatureModule({
+    feature: "proposals",
+    accounts: {
+        Proposal,
+    },
+    operations: getRuntimeOperationsForFeature("proposals"),
+    queries: {
+        fetchProposal: createAccountFetcher(Proposal),
+    },
+});
+export const createProposalsClient = proposals.client;

package/dist/src/features/smart-accounts/index.d.ts

@@ -0,0 +1,10 @@
+import { Settings, SettingsTransaction } from "@loyal-labs/loyal-smart-accounts-core";
+export declare const smartAccounts: import("../../feature-factory.js").FeatureModule<import("../../operation-registry.js").RuntimeOperationsForFeature<"smartAccounts">, {
+    Settings: typeof Settings;
+    SettingsTransaction: typeof SettingsTransaction;
+}, {
+    fetchSettings: (connection: import("@solana/web3.js").Connection, address: import("@solana/web3.js").PublicKey, commitmentOrConfig?: import("@solana/web3.js").Commitment | import("@solana/web3.js").GetAccountInfoConfig) => Promise<Settings>;
+    fetchSettingsTransaction: (connection: import("@solana/web3.js").Connection, address: import("@solana/web3.js").PublicKey, commitmentOrConfig?: import("@solana/web3.js").Commitment | import("@solana/web3.js").GetAccountInfoConfig) => Promise<SettingsTransaction>;
+}>;
+export type SmartAccountsFeature = typeof smartAccounts;
+export declare const createSmartAccountsClient: SmartAccountsFeature["client"];

package/dist/src/features/smart-accounts/index.js

@@ -0,0 +1,16 @@
+import { Settings, SettingsTransaction, } from "@loyal-labs/loyal-smart-accounts-core";
+import { createAccountFetcher, createFeatureModule } from "../../feature-factory.js";
+import { getRuntimeOperationsForFeature } from "../../operation-registry.js";
+export const smartAccounts = createFeatureModule({
+    feature: "smartAccounts",
+    accounts: {
+        Settings,
+        SettingsTransaction,
+    },
+    operations: getRuntimeOperationsForFeature("smartAccounts"),
+    queries: {
+        fetchSettings: createAccountFetcher(Settings),
+        fetchSettingsTransaction: createAccountFetcher(SettingsTransaction),
+    },
+});
+export const createSmartAccountsClient = smartAccounts.client;

package/dist/src/features/spending-limits/index.d.ts

@@ -0,0 +1,8 @@
+import { SpendingLimit } from "@loyal-labs/loyal-smart-accounts-core";
+export declare const spendingLimits: import("../../feature-factory.js").FeatureModule<import("../../operation-registry.js").RuntimeOperationsForFeature<"spendingLimits">, {
+    SpendingLimit: typeof SpendingLimit;
+}, {
+    fetchSpendingLimit: (connection: import("@solana/web3.js").Connection, address: import("@solana/web3.js").PublicKey, commitmentOrConfig?: import("@solana/web3.js").Commitment | import("@solana/web3.js").GetAccountInfoConfig) => Promise<SpendingLimit>;
+}>;
+export type SpendingLimitsFeature = typeof spendingLimits;
+export declare const createSpendingLimitsClient: SpendingLimitsFeature["client"];

package/dist/src/features/spending-limits/index.js

@@ -0,0 +1,14 @@
+import { SpendingLimit } from "@loyal-labs/loyal-smart-accounts-core";
+import { createAccountFetcher, createFeatureModule } from "../../feature-factory.js";
+import { getRuntimeOperationsForFeature } from "../../operation-registry.js";
+export const spendingLimits = createFeatureModule({
+    feature: "spendingLimits",
+    accounts: {
+        SpendingLimit,
+    },
+    operations: getRuntimeOperationsForFeature("spendingLimits"),
+    queries: {
+        fetchSpendingLimit: createAccountFetcher(SpendingLimit),
+    },
+});
+export const createSpendingLimitsClient = spendingLimits.client;

package/dist/src/features/transactions/index.d.ts

@@ -0,0 +1,12 @@
+import { LegacyTransaction, Transaction, TransactionBuffer } from "@loyal-labs/loyal-smart-accounts-core";
+export declare const transactions: import("../../feature-factory.js").FeatureModule<import("../../operation-registry.js").RuntimeOperationsForFeature<"transactions">, {
+    LegacyTransaction: typeof LegacyTransaction;
+    Transaction: typeof Transaction;
+    TransactionBuffer: typeof TransactionBuffer;
+}, {
+    fetchLegacyTransaction: (connection: import("@solana/web3.js").Connection, address: import("@solana/web3.js").PublicKey, commitmentOrConfig?: import("@solana/web3.js").Commitment | import("@solana/web3.js").GetAccountInfoConfig) => Promise<LegacyTransaction>;
+    fetchTransaction: (connection: import("@solana/web3.js").Connection, address: import("@solana/web3.js").PublicKey, commitmentOrConfig?: import("@solana/web3.js").Commitment | import("@solana/web3.js").GetAccountInfoConfig) => Promise<Transaction>;
+    fetchTransactionBuffer: (connection: import("@solana/web3.js").Connection, address: import("@solana/web3.js").PublicKey, commitmentOrConfig?: import("@solana/web3.js").Commitment | import("@solana/web3.js").GetAccountInfoConfig) => Promise<TransactionBuffer>;
+}>;
+export type TransactionsFeature = typeof transactions;
+export declare const createTransactionsClient: TransactionsFeature["client"];

package/dist/src/features/transactions/index.js

@@ -0,0 +1,18 @@
+import { LegacyTransaction, Transaction, TransactionBuffer, } from "@loyal-labs/loyal-smart-accounts-core";
+import { createAccountFetcher, createFeatureModule } from "../../feature-factory.js";
+import { getRuntimeOperationsForFeature } from "../../operation-registry.js";
+export const transactions = createFeatureModule({
+    feature: "transactions",
+    accounts: {
+        LegacyTransaction,
+        Transaction,
+        TransactionBuffer,
+    },
+    operations: getRuntimeOperationsForFeature("transactions"),
+    queries: {
+        fetchLegacyTransaction: createAccountFetcher(LegacyTransaction),
+        fetchTransaction: createAccountFetcher(Transaction),
+        fetchTransactionBuffer: createAccountFetcher(TransactionBuffer),
+    },
+});
+export const createTransactionsClient = transactions.client;

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+export { generated, PROGRAM_ID, PROGRAM_ADDRESS, spec, pda, codecs, errors, accounts, } from "@loyal-labs/loyal-smart-accounts-core";
+export * from "./client.js";
+export { programConfig } from "./features/program-config/index.js";
+export { smartAccounts } from "./features/smart-accounts/index.js";
+export { proposals } from "./features/proposals/index.js";
+export { transactions } from "./features/transactions/index.js";
+export { batches } from "./features/batches/index.js";
+export { policies } from "./features/policies/index.js";
+export { spendingLimits } from "./features/spending-limits/index.js";
+export { execution } from "./features/execution/index.js";

package/dist/src/index.js

@@ -0,0 +1,10 @@
+export { generated, PROGRAM_ID, PROGRAM_ADDRESS, spec, pda, codecs, errors, accounts, } from "@loyal-labs/loyal-smart-accounts-core";
+export * from "./client.js";
+export { programConfig } from "./features/program-config/index.js";
+export { smartAccounts } from "./features/smart-accounts/index.js";
+export { proposals } from "./features/proposals/index.js";
+export { transactions } from "./features/transactions/index.js";
+export { batches } from "./features/batches/index.js";
+export { policies } from "./features/policies/index.js";
+export { spendingLimits } from "./features/spending-limits/index.js";
+export { execution } from "./features/execution/index.js";

package/dist/src/operation-registry.d.ts

@@ -0,0 +1,85 @@
+import { OPERATION_REGISTRY as CORE_OPERATION_REGISTRY, type LoyalSmartAccountsConfirmBehavior, type LoyalSmartAccountsFeature, type LoyalSmartAccountsSendOptions, type LoyalSmartAccountsTransport, type LoyalSmartAccountsOperationMetadata, type PreparedLoyalSmartAccountsOperation } from "@loyal-labs/loyal-smart-accounts-core";
+import * as internal from "@loyal-labs/loyal-smart-accounts-core/internal";
+import type { PublicKey, Signer, TransactionInstruction } from "@solana/web3.js";
+export declare const OPERATION_BUILDERS: {
+    readonly initializeProgramConfig: typeof internal.initializeProgramConfig;
+    readonly setProgramConfigAuthority: typeof internal.setProgramConfigAuthority;
+    readonly setProgramConfigSmartAccountCreationFee: typeof internal.setProgramConfigSmartAccountCreationFee;
+    readonly setProgramConfigTreasury: typeof internal.setProgramConfigTreasury;
+    readonly createSmartAccount: typeof internal.createSmartAccount;
+    readonly addSignerAsAuthority: typeof internal.addSignerAsAuthority;
+    readonly removeSignerAsAuthority: typeof internal.removeSignerAsAuthority;
+    readonly setTimeLockAsAuthority: typeof internal.setTimeLockAsAuthority;
+    readonly changeThresholdAsAuthority: typeof internal.changeThresholdAsAuthority;
+    readonly setNewSettingsAuthorityAsAuthority: typeof internal.setNewSettingsAuthorityAsAuthority;
+    readonly setArchivalAuthorityAsAuthority: typeof internal.setArchivalAuthorityAsAuthority;
+    readonly createSettingsTransaction: typeof internal.createSettingsTransaction;
+    readonly closeSettingsTransaction: typeof internal.closeSettingsTransaction;
+    readonly createProposal: typeof internal.createProposal;
+    readonly activateProposal: typeof internal.activateProposal;
+    readonly approveProposal: typeof internal.approveProposal;
+    readonly rejectProposal: typeof internal.rejectProposal;
+    readonly cancelProposal: typeof internal.cancelProposal;
+    readonly createTransaction: typeof internal.createTransaction;
+    readonly createTransactionBuffer: typeof internal.createTransactionBuffer;
+    readonly closeTransactionBuffer: typeof internal.closeTransactionBuffer;
+    readonly extendTransactionBuffer: typeof internal.extendTransactionBuffer;
+    readonly createTransactionFromBuffer: typeof internal.createTransactionFromBuffer;
+    readonly closeTransaction: typeof internal.closeTransaction;
+    readonly logEvent: typeof internal.logEvent;
+    readonly createBatch: typeof internal.createBatch;
+    readonly addTransactionToBatch: typeof internal.addTransactionToBatch;
+    readonly closeBatchTransaction: typeof internal.closeBatchTransaction;
+    readonly closeBatch: typeof internal.closeBatch;
+    readonly createPolicyTransaction: typeof internal.createPolicyTransaction;
+    readonly closeEmptyPolicyTransaction: typeof internal.closeEmptyPolicyTransaction;
+    readonly addSpendingLimitAsAuthority: typeof internal.addSpendingLimitAsAuthority;
+    readonly removeSpendingLimitAsAuthority: typeof internal.removeSpendingLimitAsAuthority;
+    readonly useSpendingLimit: typeof internal.useSpendingLimit;
+    readonly executeSettingsTransaction: typeof internal.executeSettingsTransaction;
+    readonly executeTransaction: typeof internal.executeTransaction;
+    readonly executeBatchTransaction: typeof internal.executeBatchTransaction;
+    readonly executeTransactionSync: typeof internal.executeTransactionSync;
+    readonly executeTransactionSyncV2: typeof internal.executeTransactionSyncV2;
+    readonly executeSettingsTransactionSync: typeof internal.executeSettingsTransactionSync;
+    readonly executePolicyTransaction: typeof internal.executePolicyTransaction;
+    readonly executePolicyPayloadSync: typeof internal.executePolicyPayloadSync;
+};
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type OperationName = keyof typeof CORE_OPERATION_REGISTRY;
+type MetadataFor<K extends OperationName> = LoyalSmartAccountsOperationMetadata & (typeof CORE_OPERATION_REGISTRY)[K];
+type BuilderArgs<K extends OperationName> = Parameters<(typeof OPERATION_BUILDERS)[K]>[0];
+type ExportNameFor<K extends OperationName> = MetadataFor<K>["exportName"];
+type FeatureName = LoyalSmartAccountsFeature;
+type OperationNameForFeature<F extends FeatureName> = {
+    [K in OperationName]: MetadataFor<K>["feature"] extends F ? K : never;
+}[OperationName];
+type BoundPrepareArgs<K extends OperationName> = MetadataFor<K>["requiresConnection"] extends true ? Omit<BuilderArgs<K>, "connection"> : BuilderArgs<K>;
+type SignerAware<T> = T extends PublicKey ? PublicKey | Signer : T extends readonly (infer U)[] ? Array<SignerAware<U>> : T extends (infer U)[] ? Array<SignerAware<U>> : T;
+type ClientArgsFor<K extends OperationName> = Simplify<{
+    [P in keyof Omit<BuilderArgs<K>, "connection">]: P extends MetadataFor<K>["signerRoles"][number] ? SignerAware<Omit<BuilderArgs<K>, "connection">[P]> : Omit<BuilderArgs<K>, "connection">[P];
+} & {
+    additionalSigners?: Signer[];
+    sendOptions?: LoyalSmartAccountsSendOptions;
+    confirm?: LoyalSmartAccountsConfirmBehavior;
+}>;
+type RuntimeOperationDefinition<K extends OperationName = OperationName> = {
+    readonly name: K;
+    readonly metadata: MetadataFor<K>;
+    readonly instruction?: MetadataFor<K>["phase"] extends "offline" ? MetadataFor<K>["exposeInstruction"] extends false ? never : (args: BuilderArgs<K>) => TransactionInstruction : never;
+    readonly prepare: (args: BuilderArgs<K>) => Promise<PreparedLoyalSmartAccountsOperation<ExportNameFor<K>>>;
+    readonly boundPrepare: (transport: LoyalSmartAccountsTransport, args: BoundPrepareArgs<K>) => Promise<PreparedLoyalSmartAccountsOperation<ExportNameFor<K>>>;
+    readonly client: (transport: LoyalSmartAccountsTransport, args: ClientArgsFor<K>) => Promise<string>;
+};
+type RuntimeOperationsForFeature<F extends FeatureName> = {
+    [K in OperationNameForFeature<F> as ExportNameFor<K>]: RuntimeOperationDefinition<K>;
+};
+export declare function findRuntimeBindingIssues(): {
+    missingBuilders: ("initializeProgramConfig" | "setProgramConfigAuthority" | "setProgramConfigSmartAccountCreationFee" | "setProgramConfigTreasury" | "createSmartAccount" | "addSignerAsAuthority" | "removeSignerAsAuthority" | "setTimeLockAsAuthority" | "changeThresholdAsAuthority" | "setNewSettingsAuthorityAsAuthority" | "setArchivalAuthorityAsAuthority" | "createSettingsTransaction" | "closeSettingsTransaction" | "createProposal" | "activateProposal" | "approveProposal" | "rejectProposal" | "cancelProposal" | "createTransaction" | "createTransactionBuffer" | "closeTransactionBuffer" | "extendTransactionBuffer" | "createTransactionFromBuffer" | "closeTransaction" | "logEvent" | "createBatch" | "addTransactionToBatch" | "closeBatchTransaction" | "closeBatch" | "createPolicyTransaction" | "closeEmptyPolicyTransaction" | "addSpendingLimitAsAuthority" | "removeSpendingLimitAsAuthority" | "useSpendingLimit" | "executeSettingsTransaction" | "executeTransaction" | "executeBatchTransaction" | "executeTransactionSync" | "executeTransactionSyncV2" | "executeSettingsTransactionSync" | "executePolicyTransaction" | "executePolicyPayloadSync")[];
+    extraBuilders: string[];
+};
+export declare function assertRuntimeBindingCoverage(): void;
+export declare function getRuntimeOperationsForFeature<F extends FeatureName>(feature: F): RuntimeOperationsForFeature<F>;
+export type { BoundPrepareArgs, ClientArgsFor, FeatureName as LoyalSmartAccountsFeatureName, RuntimeOperationDefinition, RuntimeOperationsForFeature, };

package/dist/src/operation-registry.js

@@ -0,0 +1,209 @@
+import { InvalidRoleResolutionError, MissingOperationConnectionError, MissingRequiredSignerError, OPERATION_NAMES, OPERATION_REGISTRY as CORE_OPERATION_REGISTRY, OperationRegistryCoverageError, PROGRAM_ID, freezePreparedOperation, getOperationsForFeature, } from "@loyal-labs/loyal-smart-accounts-core";
+import * as internal from "@loyal-labs/loyal-smart-accounts-core/internal";
+import { sendPreparedOperation } from "@loyal-labs/loyal-smart-accounts-core";
+export const OPERATION_BUILDERS = {
+    initializeProgramConfig: internal.initializeProgramConfig,
+    setProgramConfigAuthority: internal.setProgramConfigAuthority,
+    setProgramConfigSmartAccountCreationFee: internal.setProgramConfigSmartAccountCreationFee,
+    setProgramConfigTreasury: internal.setProgramConfigTreasury,
+    createSmartAccount: internal.createSmartAccount,
+    addSignerAsAuthority: internal.addSignerAsAuthority,
+    removeSignerAsAuthority: internal.removeSignerAsAuthority,
+    setTimeLockAsAuthority: internal.setTimeLockAsAuthority,
+    changeThresholdAsAuthority: internal.changeThresholdAsAuthority,
+    setNewSettingsAuthorityAsAuthority: internal.setNewSettingsAuthorityAsAuthority,
+    setArchivalAuthorityAsAuthority: internal.setArchivalAuthorityAsAuthority,
+    createSettingsTransaction: internal.createSettingsTransaction,
+    closeSettingsTransaction: internal.closeSettingsTransaction,
+    createProposal: internal.createProposal,
+    activateProposal: internal.activateProposal,
+    approveProposal: internal.approveProposal,
+    rejectProposal: internal.rejectProposal,
+    cancelProposal: internal.cancelProposal,
+    createTransaction: internal.createTransaction,
+    createTransactionBuffer: internal.createTransactionBuffer,
+    closeTransactionBuffer: internal.closeTransactionBuffer,
+    extendTransactionBuffer: internal.extendTransactionBuffer,
+    createTransactionFromBuffer: internal.createTransactionFromBuffer,
+    closeTransaction: internal.closeTransaction,
+    logEvent: internal.logEvent,
+    createBatch: internal.createBatch,
+    addTransactionToBatch: internal.addTransactionToBatch,
+    closeBatchTransaction: internal.closeBatchTransaction,
+    closeBatch: internal.closeBatch,
+    createPolicyTransaction: internal.createPolicyTransaction,
+    closeEmptyPolicyTransaction: internal.closeEmptyPolicyTransaction,
+    addSpendingLimitAsAuthority: internal.addSpendingLimitAsAuthority,
+    removeSpendingLimitAsAuthority: internal.removeSpendingLimitAsAuthority,
+    useSpendingLimit: internal.useSpendingLimit,
+    executeSettingsTransaction: internal.executeSettingsTransaction,
+    executeTransaction: internal.executeTransaction,
+    executeBatchTransaction: internal.executeBatchTransaction,
+    executeTransactionSync: internal.executeTransactionSync,
+    executeTransactionSyncV2: internal.executeTransactionSyncV2,
+    executeSettingsTransactionSync: internal.executeSettingsTransactionSync,
+    executePolicyTransaction: internal.executePolicyTransaction,
+    executePolicyPayloadSync: internal.executePolicyPayloadSync,
+};
+function isSigner(value) {
+    return Boolean(value &&
+        typeof value === "object" &&
+        "publicKey" in value &&
+        value.publicKey &&
+        typeof value.publicKey?.toBase58 ===
+            "function");
+}
+function isPublicKey(value) {
+    return Boolean(value &&
+        typeof value === "object" &&
+        (value.constructor?.name === "PublicKey" ||
+            (typeof value.toBase58 === "function" &&
+                typeof value.toBytes === "function")));
+}
+function normalizePreparedInstruction(result) {
+    if ("instruction" in result) {
+        return {
+            instruction: result.instruction,
+            lookupTableAccounts: [...(result.lookupTableAccounts ?? [])],
+        };
+    }
+    return {
+        instruction: result,
+        lookupTableAccounts: [],
+    };
+}
+function normalizeSignerValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => normalizeSignerValue(entry));
+    }
+    if (isSigner(value)) {
+        return value.publicKey;
+    }
+    return value;
+}
+function resolvePublicKey(operation, role, value) {
+    if (isSigner(value)) {
+        return value.publicKey;
+    }
+    if (isPublicKey(value)) {
+        return value;
+    }
+    throw new InvalidRoleResolutionError(operation, role);
+}
+function normalizePreparedArgsFromClientArgs(metadata, args, transport) {
+    const next = {
+        ...args,
+    };
+    for (const [field, fallbackField] of Object.entries(metadata.signerFallbacks ?? {})) {
+        if (next[field] == null && next[fallbackField] != null) {
+            next[field] = normalizeSignerValue(next[fallbackField]);
+        }
+    }
+    for (const [field, value] of Object.entries(next)) {
+        next[field] = normalizeSignerValue(value);
+    }
+    delete next.additionalSigners;
+    delete next.sendOptions;
+    delete next.confirm;
+    if (metadata.requiresConnection) {
+        next.connection = transport.connection;
+    }
+    return next;
+}
+function collectClientSigners(metadata, args) {
+    const signers = [];
+    for (const role of metadata.signerRoles) {
+        const fallbackRole = metadata.signerFallbacks?.[role];
+        const candidate = args[role] ??
+            (fallbackRole
+                ? args[fallbackRole]
+                : undefined);
+        if (candidate == null) {
+            continue;
+        }
+        if (Array.isArray(candidate)) {
+            const missingSigner = candidate.find((entry) => !isSigner(entry));
+            if (missingSigner) {
+                throw new MissingRequiredSignerError(metadata.exportName, role);
+            }
+            signers.push(...candidate);
+            continue;
+        }
+        if (!isSigner(candidate)) {
+            throw new MissingRequiredSignerError(metadata.exportName, role);
+        }
+        signers.push(candidate);
+    }
+    if (Array.isArray(args.additionalSigners)) {
+        signers.push(...args.additionalSigners);
+    }
+    return signers;
+}
+async function prepareOperation(operationName, args) {
+    const metadata = CORE_OPERATION_REGISTRY[operationName];
+    const builder = OPERATION_BUILDERS[operationName];
+    if (metadata.requiresConnection && !("connection" in args && args.connection)) {
+        throw new MissingOperationConnectionError(metadata.exportName);
+    }
+    const result = await builder(args);
+    const normalized = normalizePreparedInstruction(result);
+    return freezePreparedOperation({
+        operation: metadata.exportName,
+        payer: resolvePublicKey(metadata.exportName, metadata.payerRole, args[metadata.payerRole]),
+        programId: args.programId ?? PROGRAM_ID,
+        requiresConfirmation: metadata.requiresConfirmation ?? false,
+        instructions: [normalized.instruction],
+        lookupTableAccounts: normalized.lookupTableAccounts,
+    });
+}
+function createRuntimeOperationDefinition(operationName) {
+    const metadata = CORE_OPERATION_REGISTRY[operationName];
+    const builder = OPERATION_BUILDERS[operationName];
+    const instruction = metadata.phase === "offline" && metadata.exposeInstruction !== false
+        ? ((args) => normalizePreparedInstruction(builder(args)).instruction)
+        : undefined;
+    return {
+        name: operationName,
+        metadata,
+        instruction: instruction,
+        prepare: (args) => prepareOperation(operationName, args),
+        boundPrepare: (transport, args) => prepareOperation(operationName, {
+            ...args,
+            ...(metadata.requiresConnection ? { connection: transport.connection } : {}),
+        }),
+        client: async (transport, args) => {
+            const prepared = await prepareOperation(operationName, normalizePreparedArgsFromClientArgs(metadata, args, transport));
+            return sendPreparedOperation({
+                transport,
+                prepared,
+                signers: collectClientSigners(metadata, args),
+                sendOptions: args.sendOptions,
+                confirm: args.confirm,
+            });
+        },
+    };
+}
+export function findRuntimeBindingIssues() {
+    const coreOperationNames = new Set(OPERATION_NAMES);
+    const builderNames = new Set(Object.keys(OPERATION_BUILDERS));
+    const missingBuilders = OPERATION_NAMES.filter((name) => !builderNames.has(name));
+    const extraBuilders = Object.keys(OPERATION_BUILDERS).filter((name) => !coreOperationNames.has(name));
+    return {
+        missingBuilders,
+        extraBuilders,
+    };
+}
+export function assertRuntimeBindingCoverage() {
+    const issues = findRuntimeBindingIssues();
+    if (issues.missingBuilders.length === 0 && issues.extraBuilders.length === 0) {
+        return;
+    }
+    throw new OperationRegistryCoverageError(`Runtime operation binding coverage failed: missing=[${issues.missingBuilders.join(", ")}] extra=[${issues.extraBuilders.join(", ")}]`);
+}
+export function getRuntimeOperationsForFeature(feature) {
+    assertRuntimeBindingCoverage();
+    return Object.fromEntries(getOperationsForFeature(feature).map((operationName) => {
+        const metadata = CORE_OPERATION_REGISTRY[operationName];
+        return [metadata.exportName, createRuntimeOperationDefinition(operationName)];
+    }));
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@loyal-labs/loyal-smart-accounts",
+  "version": "0.1.1",
+  "description": "Universal TypeScript SDK for the Squads Smart Account program",
+  "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"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "build": "bun run clean && tsc -p tsconfig.build.json",
+    "prepublishOnly": "bun run build",
+    "clean": "rm -rf dist",
+    "test": "bun test",
+    "validate:surface": "bun test tests/operation-registry.test.ts"
+  },
+  "keywords": [
+    "solana",
+    "smart-account",
+    "squads",
+    "wallet",
+    "multisig",
+    "web3",
+    "blockchain"
+  ],
+  "author": "Loyal",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/loyal-labs/loyal-app.git",
+    "directory": "sdk/loyal-smart-accounts"
+  },
+  "bugs": {
+    "url": "https://github.com/loyal/loyal-app/issues"
+  },
+  "homepage": "https://github.com/loyal/loyal-app/tree/main/sdk/loyal-smart-accounts#readme",
+  "peerDependencies": {
+    "@solana/web3.js": "^1.98.0"
+  },
+  "dependencies": {
+    "@loyal-labs/loyal-smart-accounts-core": "^0.1.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/node": "^24.0.15",
+    "typescript": "^5.7.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}