> ## Documentation Index
> Fetch the complete documentation index at: https://docs.eco.com/llms.txt
> Use this file to discover all available pages before exploring further.

# svm: Address lookup tables

> Address lookup tables: 9 exports of the svm module of @eco-incorp/sauce, including selectAltAddresses, createAltWithAddresses, extendAlt, waitForAltActive, fetchAlt, LOOKUP_TABLE_MAX_ADDRESSES.

`@eco-incorp/sauce/svm` is the Solana side: staging a program through the kitchen, resolving accounts against the compiler's account manifest, building and sending transactions, and verifying settle programs. Solana execution goes through the Kitchen client here; the SDK's SVM route helpers emit a legacy instruction that the released engine does not accept.

```typescript theme={null}
import { createSauceSvmClient } from "@eco-incorp/sauce/svm";
```

This page covers `sdk/dist/svm/alt.d.ts`.

<Note>
  Generated from the type declarations shipped in `@eco-incorp/sauce` 0.99.4. Each entry shows the package authors' JSDoc and declaration for this SDK version. For runtime compatibility and deployed addresses, see [architecture and deployments](/programmable-transactions/sauce/architecture-and-deployments).
</Note>

### `selectAltAddresses`

*Function* · `sdk/dist/svm/alt.d.ts`

Picks the account addresses worth putting in a lookup table: non-signers
only (signers must be static message accounts - they cannot be looked up),
deduplicated in first-seen order.

```typescript theme={null}
export declare function selectAltAddresses(metas: readonly ResolvedAccountMeta[]): Address[];
```

### `createAltWithAddresses`

*Function* · `sdk/dist/svm/alt.d.ts`

Creates an address lookup table and extends it with `addresses` (one create
transaction, then one transaction per chunk of 30 addresses - 27 when payer
and authority are distinct signers). Returns the table address and a slot
upper bound for the last extend - feed it to `waitForAltActive` before
compressing a transaction against the table.

More than LOOKUP\_TABLE\_MAX\_ADDRESSES addresses throws before the create
transaction is built, so no table is funded.

```typescript theme={null}
export declare function createAltWithAddresses({ rpc, payer, authority, addresses, sendAndConfirm, commitment, }: CreateAltInput): Promise<{
    lookupTableAddress: Address;
    lastExtendedSlot: bigint;
}>;
```

### `extendAlt`

*Function* · `sdk/dist/svm/alt.d.ts`

Appends `addresses` to an existing lookup table (one transaction per chunk of
30 - 27 with a distinct authority), returning a slot upper bound for the last
extend. Feed it to `waitForAltActive` before compressing against the table.
An empty `addresses` sends nothing and returns the current slot (the table is
already sufficient) - this is the idempotent no-op the reuse path relies on.

More than LOOKUP\_TABLE\_MAX\_ADDRESSES throws before the first chunk goes out:
the chunks are sent sequentially, so a set that cannot fit would otherwise
rent-fund a half-filled table before failing on-chain.

```typescript theme={null}
export declare function extendAlt({ rpc, payer, authority, lookupTableAddress, addresses, sendAndConfirm, commitment, }: ExtendAltInput): Promise<{
    lastExtendedSlot: bigint;
}>;
```

### `waitForAltActive`

*Function* · `sdk/dist/svm/alt.d.ts`

Waits until the lookup table is usable. Addresses extended in slot N are
usable from slot N+1 onward, so this resolves once getSlot() > lastExtendedSlot.

```typescript theme={null}
export declare function waitForAltActive(rpc: Rpc<GetSlotApi>, lastExtendedSlot: bigint, { timeoutMs, pollMs }?: {
    timeoutMs?: number;
    pollMs?: number;
}): Promise<void>;
```

### `fetchAlt`

*Function* · `sdk/dist/svm/alt.d.ts`

Fetches a lookup table in the shape `compressTransactionMessageUsingAddressLookupTables` consumes.

```typescript theme={null}
export declare function fetchAlt(rpc: Parameters<typeof fetchAddressLookupTable>[0], lookupTableAddress: Address): Promise<AddressesByLookupTableAddress>;
```

### `LOOKUP_TABLE_MAX_ADDRESSES`

*Variable* · `sdk/dist/svm/alt.d.ts`

Hard on-chain capacity of one address lookup table (LOOKUP\_TABLE\_MAX\_ADDRESSES
in solana-program). The extend instruction that would cross it fails, and
because the extends are sent sequentially the earlier ones have already
landed - so callers must reject an oversized set BEFORE sending anything
rather than leave a half-filled, rent-funded table behind.

```typescript theme={null}
LOOKUP_TABLE_MAX_ADDRESSES = 256
```

### `SendAndConfirmTransaction`

*Type* · `sdk/dist/svm/alt.d.ts`

```typescript theme={null}
export type SendAndConfirmTransaction = (transaction: SignedExecuteTransaction, config: {
    commitment: Commitment;
}) => Promise<void>;
```

### `CreateAltInput`

*Interface* · `sdk/dist/svm/alt.d.ts`

```typescript theme={null}
export interface CreateAltInput {
    rpc: Rpc<GetLatestBlockhashApi & GetSlotApi>;
    payer: TransactionSigner;
    authority: TransactionSigner;
    addresses: readonly Address[];
    sendAndConfirm: SendAndConfirmTransaction;
    commitment?: Commitment;
}
```

### `ExtendAltInput`

*Interface* · `sdk/dist/svm/alt.d.ts`

```typescript theme={null}
export interface ExtendAltInput {
    rpc: Rpc<GetLatestBlockhashApi & GetSlotApi>;
    payer: TransactionSigner;
    authority: TransactionSigner;
    lookupTableAddress: Address;
    addresses: readonly Address[];
    sendAndConfirm: SendAndConfirmTransaction;
    commitment?: Commitment;
}
```