apply review fixes, simplify delegate and frozen reasoning

Author: SwenSchaeferjohann

js/compressed-token/src/v3/actions/load-ata.ts

@@ -11,9 +11,7 @@ import {
     TransactionSignature,
     ConfirmOptions,
 } from '@solana/web3.js';
-import {
-    createLoadAtaInstructions,
-} from '../instructions/load-ata';
+import { createLoadAtaInstructions } from '../instructions/load-ata';
 import { InterfaceOptions } from './transfer-interface';
 
 export {
@@ -60,12 +58,7 @@ export async function loadAta(
 
     const txPromises = batches.map(async ixs => {
         const { blockhash } = await rpc.getLatestBlockhash();
-        const tx = buildAndSignTx(
-            ixs,
-            payer!,
-            blockhash,
-            additionalSigners,
-        );
+        const tx = buildAndSignTx(ixs, payer!, blockhash, additionalSigners);
         return sendAndConfirmTx(rpc, tx, confirmOptions);
     });
 

js/compressed-token/src/v3/actions/transfer-interface.ts

@@ -19,6 +19,10 @@ import { type SplInterfaceInfo } from '../../utils/get-token-pool-infos';
 
 export interface InterfaceOptions {
     splInterfaceInfos?: SplInterfaceInfo[];
+    /**
+     * ATA owner (authority owner) used to derive the ATA when the signer is a
+     * delegate. For owner-signed flows, omit this field.
+     */
     owner?: PublicKey;
 }
 
@@ -88,7 +92,6 @@ export interface TransferOptions extends InterfaceOptions {
     wrap?: boolean;
     programId?: PublicKey;
     ensureRecipientAta?: boolean;
-    owner?: PublicKey;
 }
 
 export function sliceLast<T>(items: T[]): { rest: T[]; last: T } {

js/compressed-token/src/v3/get-account-interface.ts

@@ -901,11 +901,49 @@ export function buildAccountInterfaceFromSources(
     const hasDelegate = sources.some(src => src.parsed.delegate !== null);
     const anyFrozen = sources.some(src => src.parsed.isFrozen);
     const needsConsolidation = sources.length > 1;
+    const delegateTotals = new Map<
+        string,
+        { delegate: PublicKey; total: bigint; firstIndex: number }
+    >();
+    for (let i = 0; i < sources.length; i++) {
+        const src = sources[i];
+        const delegate = src.parsed.delegate;
+        if (!delegate) continue;
+        const key = delegate.toBase58();
+        const delegated = src.parsed.delegatedAmount ?? src.amount;
+        const spendable = src.amount < delegated ? src.amount : delegated;
+        const existing = delegateTotals.get(key);
+        if (existing) {
+            existing.total += spendable;
+        } else {
+            delegateTotals.set(key, {
+                delegate,
+                total: spendable,
+                firstIndex: i,
+            });
+        }
+    }
+    let canonicalDelegate: PublicKey | null = null;
+    let canonicalDelegatedAmount = BigInt(0);
+    let canonicalFirstIndex = Number.MAX_SAFE_INTEGER;
+    for (const { delegate, total, firstIndex } of delegateTotals.values()) {
+        if (
+            total > canonicalDelegatedAmount ||
+            (total === canonicalDelegatedAmount &&
+                firstIndex < canonicalFirstIndex)
+        ) {
+            canonicalDelegate = delegate;
+            canonicalDelegatedAmount = total;
+            canonicalFirstIndex = firstIndex;
+        }
+    }
 
     const unifiedAccount: Account = {
         ...primarySource.parsed,
         address: canonicalAddress,
         amount: totalAmount,
+        delegate: canonicalDelegate,
+        delegatedAmount: canonicalDelegatedAmount,
         ...(anyFrozen ? { state: AccountState.Frozen, isFrozen: true } : {}),
     };
 
@@ -924,38 +962,30 @@ export function buildAccountInterfaceFromSources(
 /**
  * Spendable amount for a given authority (owner or delegate).
  * - If authority equals the ATA owner: full parsed.amount.
- * - If authority is a delegate: sum over sources where delegate === authority
- *   of min(source.amount, source.delegatedAmount).
- *
- * For compress-and-close accounts (CompressedOnly TLV), decompress carries
- * delegate state to the hot ATA. For approve-style accounts (no TLV), the
- * delegate is set in token data but NOT applied to the hot ATA on decompress.
- * The transfer-interface validates this and errors for approve-style cold
- * sources that require loading.
+ * - If authority is the canonical delegate: parsed.delegatedAmount (bounded by parsed.amount).
+ * - Otherwise: 0.
  * @internal
  */
 export function spendableAmountForAuthority(
     iface: AccountInterface,
     authority: PublicKey,
 ): bigint {
     const owner = iface._owner;
-    const sources = iface._sources ?? [];
     if (owner && authority.equals(owner)) {
         return iface.parsed.amount;
     }
-    let sum = BigInt(0);
-    for (const src of sources) {
-        if (src.parsed.delegate && authority.equals(src.parsed.delegate)) {
-            const amt = src.amount;
-            const delegated = src.parsed.delegatedAmount ?? amt;
-            sum += amt < delegated ? amt : delegated;
-        }
+    const delegate = iface.parsed.delegate;
+    if (delegate && authority.equals(delegate)) {
+        const delegated = iface.parsed.delegatedAmount ?? BigInt(0);
+        return delegated < iface.parsed.amount
+            ? delegated
+            : iface.parsed.amount;
     }
-    return sum;
+    return BigInt(0);
 }
 
 /**
- * Whether the given authority can sign for this ATA (is owner or delegate of at least one source).
+ * Whether the given authority can sign for this ATA (owner or canonical delegate).
  * @internal
  */
 export function isAuthorityForInterface(
@@ -964,57 +994,57 @@ export function isAuthorityForInterface(
 ): boolean {
     const owner = iface._owner;
     if (owner && authority.equals(owner)) return true;
-    const sources = iface._sources ?? [];
-    return sources.some(
-        src =>
-            src.parsed.delegate !== null &&
-            authority.equals(src.parsed.delegate),
-    );
+    const delegate = iface.parsed.delegate;
+    return delegate !== null && authority.equals(delegate);
 }
 
 /**
  * @internal
- * Filter an AccountInterface to only sources the given authority can use (owner or delegate).
- * Preserves _owner, _mint, _isAta. Use for load/transfer when authority is delegate.
+ * Canonical authority projection for owner/delegate checks.
  */
 export function filterInterfaceForAuthority(
     iface: AccountInterface,
     authority: PublicKey,
 ): AccountInterface {
-    const sources = iface._sources ?? [];
     const owner = iface._owner;
-    const filtered = sources.filter(
-        src =>
-            (owner && authority.equals(owner)) ||
-            (src.parsed.delegate !== null &&
-                authority.equals(src.parsed.delegate)),
-    );
-    if (filtered.length === 0) {
+    if (owner && authority.equals(owner)) {
+        return iface;
+    }
+    const spendable = spendableAmountForAuthority(iface, authority);
+    const canonicalDelegate = iface.parsed.delegate;
+    if (
+        spendable === BigInt(0) ||
+        canonicalDelegate === null ||
+        !authority.equals(canonicalDelegate)
+    ) {
         return {
             ...iface,
             _sources: [],
+            _needsConsolidation: false,
             parsed: { ...iface.parsed, amount: BigInt(0) },
         };
     }
-    const spendable = spendableAmountForAuthority(iface, authority);
+    const sources = iface._sources ?? [];
+    const filtered = sources.filter(
+        src =>
+            src.parsed.delegate !== null &&
+            src.parsed.delegate.equals(canonicalDelegate),
+    );
     const primary = filtered[0];
-    const anyFrozen = filtered.some(s => s.parsed.isFrozen);
     return {
         ...iface,
+        ...(primary
+            ? {
+                  accountInfo: primary.accountInfo!,
+                  isCold: isColdSourceType(primary.type),
+                  loadContext: primary.loadContext,
+              }
+            : {}),
         _sources: filtered,
-        accountInfo: primary.accountInfo!,
+        _needsConsolidation: filtered.length > 1,
         parsed: {
-            ...primary.parsed,
-            address: iface.parsed.address,
+            ...iface.parsed,
             amount: spendable,
-            ...(anyFrozen
-                ? { state: AccountState.Frozen, isFrozen: true }
-                : {}),
         },
-        isCold: isColdSourceType(primary.type),
-        loadContext: primary.loadContext,
-        _needsConsolidation: filtered.length > 1,
-        _hasDelegate: filtered.some(s => s.parsed.delegate !== null),
-        _anyFrozen: anyFrozen,
     };
 }

js/compressed-token/src/v3/instructions/create-decompress-interface-instruction.ts

@@ -64,7 +64,7 @@ function parseCompressedOnlyFromTlv(
                 30: 1,
                 31: 17,
             };
-            const size = SIZES[disc] ?? 0;
+            const size = SIZES[disc];
             if (size === undefined) return null;
             offset += size;
         }
@@ -118,6 +118,8 @@ function buildInTlv(
                     delegatedAmount: co.delegatedAmount,
                     withheldTransferFee: co.withheldTransferFee,
                     isFrozen,
+                    // This builder emits a single decompress compression per batch.
+                    // Keep index at 0 unless multi-compression output is added here.
                     compressionIndex: 0,
                     isAta: co.isAta,
                     bump,
@@ -416,6 +418,18 @@ export function createDecompressInterfaceInstruction(
         registeredProgramPda,
         accountCompressionProgram,
     } = defaultStaticAccountsStruct();
+    const signerIndex = (() => {
+        if (!authority || authority.equals(owner)) {
+            return ownerIndex;
+        }
+        const authorityIndex = packedAccountIndices.get(authority.toBase58());
+        if (authorityIndex === undefined) {
+            throw new Error(
+                `Authority ${authority.toBase58()} is not present in packed accounts`,
+            );
+        }
+        return authorityIndex;
+    })();
 
     const keys = [
         // 0: light_system_program (non-mutable)
@@ -463,12 +477,6 @@ export function createDecompressInterfaceInstruction(
             const isPool =
                 splInterfaceInfo !== undefined &&
                 pubkey.equals(splInterfaceInfo.splInterfacePda);
-            const signerIndex =
-                authority &&
-                !authority.equals(owner) &&
-                packedAccountIndices.has(authority.toBase58())
-                    ? packedAccountIndices.get(authority.toBase58())!
-                    : ownerIndex;
             return {
                 pubkey,
                 isSigner: i === signerIndex,

js/compressed-token/src/v3/instructions/load-ata.ts

@@ -101,7 +101,6 @@ export function getCompressedTokenAccountsFromAtaSources(
     return sources
         .filter(source => source.loadContext !== undefined)
         .filter(source => COLD_SOURCE_TYPES.has(source.type))
-        .filter(source => !source.parsed.isFrozen)
         .map(source => {
             const fullData = source.accountInfo.data;
             const discriminatorBytes = fullData.subarray(
@@ -197,12 +196,6 @@ export async function createLoadAtaInstructions(
             );
         }
         accountInterface = filterInterfaceForAuthority(accountInterface, owner);
-        if (
-            (accountInterface._sources?.length ?? 0) === 0 ||
-            accountInterface.parsed.amount === BigInt(0)
-        ) {
-            return [];
-        }
     }
 
     const internalBatches = await _buildLoadBatches(
@@ -318,16 +311,10 @@ export async function _buildLoadBatches(
         );
     }
 
-    const splSource = sources.find(s => s.type === 'spl' && !s.parsed.isFrozen);
-    const t22Source = sources.find(
-        s => s.type === 'token2022' && !s.parsed.isFrozen,
-    );
-    const ctokenHotSource = sources.find(
-        s => s.type === 'ctoken-hot' && !s.parsed.isFrozen,
-    );
-    const coldSources = sources.filter(
-        s => COLD_SOURCE_TYPES.has(s.type) && !s.parsed.isFrozen,
-    );
+    const splSource = sources.find(s => s.type === 'spl');
+    const t22Source = sources.find(s => s.type === 'token2022');
+    const ctokenHotSource = sources.find(s => s.type === 'ctoken-hot');
+    const coldSources = sources.filter(s => COLD_SOURCE_TYPES.has(s.type));
 
     const splBalance = splSource?.amount ?? BigInt(0);
     const t22Balance = t22Source?.amount ?? BigInt(0);

js/compressed-token/src/v3/instructions/transfer-interface.ts

@@ -35,7 +35,6 @@ import {
     filterInterfaceForAuthority,
 } from '../get-account-interface';
 import { assertTransactionSizeWithinLimit } from '../utils/estimate-tx-size';
-import { COLD_SOURCE_TYPES } from '../get-account-interface';
 import type { TransferOptions } from '../actions/transfer-interface';
 
 const LIGHT_TOKEN_TRANSFER_DISCRIMINATOR = 3;
@@ -208,25 +207,6 @@ export async function createTransferInterfaceInstructions(
         sender,
     );
 
-    if (isDelegate && internalBatches.length > 0) {
-        const sources = senderInterface._sources ?? [];
-        const hasApproveStyleCold = sources.some(
-            s =>
-                COLD_SOURCE_TYPES.has(s.type) &&
-                s.parsed.delegate !== null &&
-                s.parsed.delegate.equals(sender) &&
-                (!s.parsed.tlvData || s.parsed.tlvData.length === 0),
-        );
-        if (hasApproveStyleCold) {
-            throw new Error(
-                'Delegate transfer requires loading cold sources that were delegated ' +
-                    'via approve (no CompressedOnly TLV). Decompress will not carry ' +
-                    'the delegate to the hot ATA. Load as owner first, then approve ' +
-                    'the delegate on the hot ATA.',
-            );
-        }
-    }
-
     let transferIx: TransactionInstruction;
     if (isSplOrT22 && !wrap) {
         const mintInfo = await getMint(rpc, mint, undefined, programId);

js/compressed-token/src/v3/instructions/unwrap.ts

@@ -4,7 +4,11 @@ import {
     TransactionInstruction,
     SystemProgram,
 } from '@solana/web3.js';
-import { Rpc, assertBetaEnabled, LIGHT_TOKEN_PROGRAM_ID } from '@lightprotocol/stateless.js';
+import {
+    Rpc,
+    assertBetaEnabled,
+    LIGHT_TOKEN_PROGRAM_ID,
+} from '@lightprotocol/stateless.js';
 import { getMint, TokenAccountNotFoundError } from '@solana/spl-token';
 import type BN from 'bn.js';
 import { MAX_TOP_UP } from '../../constants';
@@ -216,6 +220,10 @@ export async function createUnwrapInstructions(
     const unwrapAmount =
         amount != null ? BigInt(amount.toString()) : totalBalance;
 
+    if (unwrapAmount === BigInt(0)) {
+        throw new Error('Unwrap amount must be greater than zero.');
+    }
+
     if (unwrapAmount > totalBalance) {
         throw new Error(
             `Insufficient light-token balance. Requested: ${unwrapAmount}, Available: ${totalBalance}`,
@@ -229,7 +237,7 @@ export async function createUnwrapInstructions(
         interfaceOptions,
         wrap,
         ctokenAta,
-        amount !== undefined ? unwrapAmount : undefined,
+        amount != null ? unwrapAmount : undefined,
     );
 
     const mintInfo = await getMint(