Balance not fetching correctly

[Arpit-R-Doshi]

This is the getBalance.ts file which we are using to check the balance of our wallet.
Complete Code:

// src/getBalance.ts

import WebSocket from 'ws';
import {
    createAuthRequestMessage,
    createAuthVerifyMessage,
    createEIP712AuthMessageSigner,
    parseAnyRPCResponse,
    RPCMethod,
    type AuthChallengeResponse,
    type AuthRequestParams,
    type AuthVerifyResponse,
    createECDSAMessageSigner,
    createGetLedgerBalancesMessage,
    type GetLedgerBalancesResponse,
} from '@erc7824/nitrolite';
import { createWalletClient, http } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { mainnet } from 'viem/chains';

// --- Main Function ---
export async function authenticateAndGetBalance(
    wsUrl: string,
    mainAccount: { address: `0x${string}`; privateKey: `0x${string}` },
    targetAddress: `0x${string}`
): Promise<any[]> {
    const sessionKey = mainAccount;
    const account = privateKeyToAccount(mainAccount.privateKey);
    const walletClient = createWalletClient({ account, chain: mainnet, transport: http() });
    const ws = new WebSocket(wsUrl);
    let sessionExpireTimestamp = '';

    return new Promise((resolve, reject) => {
        ws.on('open', async () => {
            console.log(`1. WebSocket Connected. Authenticating as ${mainAccount.address}...`);
            try {
                sessionExpireTimestamp = String(Math.floor(Date.now() / 1000) + 3600);
                const authParams: AuthRequestParams = {
                    address: mainAccount.address, session_key: sessionKey.address,
                    app_name: 'My Test App', expire: sessionExpireTimestamp,
                    scope: 'test-app.com', application: mainAccount.address, allowances: [],
                };
                const authRequestPayload = await createAuthRequestMessage(authParams);
                ws.send(authRequestPayload);
            } catch (err) { reject(err); }
        });

        ws.on('message', async (data: WebSocket.Data) => {
            // --- THIS IS THE CRITICAL DEBUGGING LINE ---
            console.log('\n--- RAW SERVER RESPONSE ---');
            console.log(data.toString());
            console.log('---------------------------\n');
            // --- END OF DEBUGGING LINE ---

            const response = parseAnyRPCResponse(data.toString());
            if (!response) {
                // If the SDK can't parse it, maybe it's the simple {res: [...]} format
                try {
                    const simpleResponse = JSON.parse(data.toString());
                    if (simpleResponse.res && simpleResponse.res[1] === 'get_ledger_balances') {
                        console.log('4. Balance response received (parsed manually)!');
                        const balances = simpleResponse.res[2][0] || [];
                        resolve(balances);
                        ws.close();
                    }
                } catch {
                    // Ignore if it's not JSON
                }
                return;
            }

            switch (response.method) {
                case RPCMethod.AuthChallenge: {
                    console.log('2. Received authentication challenge. Signing...');
                    const challengeResponse = response as AuthChallengeResponse;
                    const eip712SignerParams = {
                        scope: 'test-app.com', application: mainAccount.address,
                        participant: sessionKey.address, expire: sessionExpireTimestamp, allowances: [],
                    };
                    const eip712Domain = { name: 'My Test App' };
                    const eip712Signer = createEIP712AuthMessageSigner(walletClient, eip712SignerParams, eip712Domain);
                    const authVerifyPayload = await createAuthVerifyMessage(eip712Signer, challengeResponse);
                    ws.send(authVerifyPayload);
                    break;
                }
                case RPCMethod.AuthVerify: {
                    if (response.params?.success) {
                        console.log(`3. Authentication successful! Now fetching balance for ${targetAddress}...`);
                        const sessionSigner = createECDSAMessageSigner(sessionKey.privateKey);
                        const getBalancesPayload = await createGetLedgerBalancesMessage(sessionSigner, targetAddress);
                        console.log('Sending get_ledger_balances request...');
                        ws.send(getBalancesPayload);
                    } else { reject('Authentication verification failed.'); ws.close(); }
                    break;
                }
                case RPCMethod.GetLedgerBalances: {
                    console.log('4. Balance response received (parsed by SDK)!');
                    const balanceResponse = response as GetLedgerBalancesResponse;
                    const balances = balanceResponse.params.ledgerBalances || [];
                    resolve(balances);
                    ws.close();
                    break;
                }
                case RPCMethod.Error: { reject(`Request failed: ${response.params.error}`); ws.close(); break; }
            }
        });

        ws.on('error', (err: Error) => reject(`WebSocket error: ${err.message}`));
        ws.on('close', () => console.log('WebSocket connection closed.'));
    });
}

// --- Example Usage ---
const signingAccount = {
    address: '0xfC6e3552507144066e190a371648f6FF734bb4b0' as const,
    privateKey: '0xc4c317d0860d15e98aacb3fc1c1141b3fa1559009208938678de252934319f8e' as const,
};
const targetAddress = '0x70997970C51812dc3A010C7d01b50e0d17dc79C8' as const;
const wsUrl = 'wss://clearnet-sandbox.yellow.com/ws';

authenticateAndGetBalance(wsUrl, signingAccount, targetAddress)
    .then(balances => {
        console.log(`\n--- Wallet Balances for ${targetAddress} ---`);
        if (balances.length === 0) {
            console.log('Authentication was successful, but the final parsed balance array was empty.');
        } else {
            balances.forEach((balance: { asset: string, amount: string }) => {
                console.log(`Asset: ${balance.asset}, Amount: ${balance.amount}`);
            });
        }
        console.log('-----------------------------------------------------\n');
    })
    .catch(err => {
        console.error('\n--- SCRIPT FAILED ---');
        console.error(err);
        console.log('---------------------\n');
    });

Now the issue is when i run curl command to get funds from the sandbox, it shows as funds are sent, but when I check balance I cannot see the funds in my wallet.

I have attached the screenshot below:

[philanton]

I suspect that something is wrong with authentication, because the signer (your signingAccount address) is not linked to your wallet (targetAddress), I also see in the code mainAccount, but I'm not sure what it is.

What I can suggest you, is to make sure that the targetAddress equals mainAccount.address

[nksazonov]

@Arpit-R-Doshi , just checking in. Were you able to resolve your issue?

[Arpit-R-Doshi]

Yes we were able to resolve the issue, the issue apparently was that the fetch function wasn't working on the server side, the problem stopped when we fetched the balance along with transfer also we had to change the address of the wallet because it was giving null balance for the account where no funds were available, so in short the fetch balance function itself doesn't work but it works when we fetch during transfers.

…

On Thu, Sep 25, 2025, 13:41 Sazonov Nikita ***@***.***> wrote: @Arpit-R-Doshi <https://github.com/Arpit-R-Doshi> , just checking in. Were you able to resolve your issue? — Reply to this email directly, view it on GitHub <#26 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/BMBULZBXJVWAYOVMPTWLMSL3UOPRPAVCNFSM6AAAAACHNHVW6SVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTINJQG43DONY> . You are receiving this because you were mentioned.Message ID: ***@***.***>