@toon-protocol/connector 2.6.1 → 3.3.1

package/dist/settlement/solana-payment-channel-sdk.js

@@ -1,636 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateKeyPairSigner = exports.SolanaPaymentChannelSDK = exports.SolanaChannelError = void 0;
-exports.mapProgramError = mapProgramError;
-exports.parseSolanaError = parseSolanaError;
-exports.deserializeChannelState = deserializeChannelState;
-exports.buildEd25519PrecompileInstruction = buildEd25519PrecompileInstruction;
-const tslib_1 = require("tslib");
-const crypto = tslib_1.__importStar(require("crypto"));
-const kit_1 = require("@solana/kit");
-Object.defineProperty(exports, "generateKeyPairSigner", { enumerable: true, get: function () { return kit_1.generateKeyPairSigner; } });
-const CHANNEL_DISCRIMINATOR = new Uint8Array([0x70, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c]);
-const DISCRIMINATORS = {
-    INITIALIZE_CHANNEL: new Uint8Array([0x01, 0, 0, 0, 0, 0, 0, 0]),
-    DEPOSIT: new Uint8Array([0x02, 0, 0, 0, 0, 0, 0, 0]),
-    CLOSE_CHANNEL: new Uint8Array([0x03, 0, 0, 0, 0, 0, 0, 0]),
-    SETTLE_CHANNEL: new Uint8Array([0x04, 0, 0, 0, 0, 0, 0, 0]),
-    FORCE_CLOSE_EXPIRED: new Uint8Array([0x05, 0, 0, 0, 0, 0, 0, 0]),
-    CLAIM_FROM_CHANNEL: new Uint8Array([0x06, 0, 0, 0, 0, 0, 0, 0]),
-};
-const ACCOUNT_SIZE = 178;
-const SYSTEM_PROGRAM = '11111111111111111111111111111111';
-const TOKEN_PROGRAM = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA';
-const RENT_SYSVAR = 'SysvarRent111111111111111111111111111111111';
-const CLOCK_SYSVAR = 'SysvarC1ock11111111111111111111111111111111';
-const INSTRUCTIONS_SYSVAR = 'Sysvar1nstructions1111111111111111111111111';
-const ED25519_PROGRAM = 'Ed25519SigVerify111111111111111111111111111';
-const ERROR_CODE_MAP = {
-    0: 'ChannelAlreadyExists',
-    1: 'ChannelNotOpened',
-    2: 'ChannelNotClosed',
-    3: 'ChannelChallengeNotExpired',
-    4: 'InvalidParticipant',
-    5: 'ZeroAmountDeposit',
-    6: 'NonceNotMonotonic',
-    7: 'TransferredAmountDecreased',
-    8: 'InvalidSignature',
-    9: 'UnauthorizedSigner',
-    10: 'ArithmeticOverflow',
-    11: 'InvalidPDA',
-    12: 'InvalidVaultPDA',
-};
-class SolanaChannelError extends Error {
-    code;
-    errorName;
-    constructor(message, code, errorName) {
-        super(message);
-        this.code = code;
-        this.errorName = errorName;
-        this.name = 'SolanaChannelError';
-        Error.captureStackTrace(this, SolanaChannelError);
-    }
-}
-exports.SolanaChannelError = SolanaChannelError;
-function toMutableBytes(readonly) {
-    return new Uint8Array(readonly);
-}
-const MAX_U64 = (1n << 64n) - 1n;
-function writeUint64LE(buf, offset, value) {
-    if (value < 0n || value > MAX_U64) {
-        throw new RangeError(`Value ${value} is outside u64 range [0, 2^64-1]`);
-    }
-    for (let i = 0; i < 8; i++) {
-        buf[offset + i] = Number((value >> BigInt(i * 8)) & 0xffn);
-    }
-}
-function readUint64LE(buf, offset) {
-    let result = 0n;
-    for (let i = 0; i < 8; i++) {
-        result |= BigInt(buf[offset + i] ?? 0) << BigInt(i * 8);
-    }
-    return result;
-}
-function readInt64LE(buf, offset) {
-    const unsigned = readUint64LE(buf, offset);
-    if (unsigned >= 1n << 63n) {
-        return unsigned - (1n << 64n);
-    }
-    return unsigned;
-}
-function sortParticipants(a, b) {
-    const encoder = (0, kit_1.getAddressEncoder)();
-    const aBytes = toMutableBytes(encoder.encode(a));
-    const bBytes = toMutableBytes(encoder.encode(b));
-    for (let i = 0; i < 32; i++) {
-        const aByte = aBytes[i] ?? 0;
-        const bByte = bBytes[i] ?? 0;
-        if (aByte < bByte)
-            return [a, b];
-        if (aByte > bByte)
-            return [b, a];
-    }
-    return [a, b];
-}
-function mapStateU8(val) {
-    switch (val) {
-        case 0:
-            return 'opened';
-        case 1:
-            return 'closed';
-        case 2:
-            return 'settled';
-        default:
-            throw new Error(`Unknown channel state byte: ${val}`);
-    }
-}
-function mapProgramError(code) {
-    const errorName = ERROR_CODE_MAP[code] ?? `UnknownError(${code})`;
-    return new SolanaChannelError(`Solana payment channel program error: ${errorName} (code ${code})`, code, errorName);
-}
-function parseSolanaError(err) {
-    if (err instanceof Error) {
-        const message = err.message;
-        const hexMatch = /custom program error: 0x([0-9a-fA-F]+)/.exec(message);
-        if (hexMatch?.[1]) {
-            const code = parseInt(hexMatch[1], 16);
-            if (code >= 0 && code <= 12) {
-                throw mapProgramError(code);
-            }
-        }
-        const customMatch = /Custom:\s*(\d+)/.exec(message);
-        if (customMatch?.[1]) {
-            const code = parseInt(customMatch[1], 10);
-            if (code >= 0 && code <= 12) {
-                throw mapProgramError(code);
-            }
-        }
-        const instructionErrorMatch = /InstructionError.*Custom.*?(\d+)/.exec(message);
-        if (instructionErrorMatch?.[1]) {
-            const code = parseInt(instructionErrorMatch[1], 10);
-            if (code >= 0 && code <= 12) {
-                throw mapProgramError(code);
-            }
-        }
-    }
-    throw err;
-}
-function deserializeChannelState(data) {
-    if (data.length < ACCOUNT_SIZE) {
-        throw new Error(`Channel account data too short: expected ${ACCOUNT_SIZE} bytes, got ${data.length}`);
-    }
-    for (let i = 0; i < 8; i++) {
-        if (data[i] !== CHANNEL_DISCRIMINATOR[i]) {
-            throw new Error('Invalid channel account discriminator: expected "pchannel"');
-        }
-    }
-    const decoder = (0, kit_1.getAddressDecoder)();
-    return {
-        participantA: decoder.decode(data.slice(8, 40)),
-        participantB: decoder.decode(data.slice(40, 72)),
-        tokenMint: decoder.decode(data.slice(72, 104)),
-        depositA: readUint64LE(data, 104),
-        depositB: readUint64LE(data, 112),
-        transferredAmountA: readUint64LE(data, 120),
-        transferredAmountB: readUint64LE(data, 128),
-        nonceA: readUint64LE(data, 136),
-        nonceB: readUint64LE(data, 144),
-        challengeDuration: readUint64LE(data, 152),
-        state: mapStateU8(data[160] ?? 0),
-        closeTimestamp: readInt64LE(data, 161),
-        bump: data[169] ?? 0,
-    };
-}
-function buildEd25519PrecompileInstruction(signature, pubkey, message) {
-    if (signature.length !== 64) {
-        throw new Error(`Ed25519 signature must be 64 bytes, got ${signature.length}`);
-    }
-    if (pubkey.length !== 32) {
-        throw new Error(`Ed25519 public key must be 32 bytes, got ${pubkey.length}`);
-    }
-    if (message.length === 0) {
-        throw new Error('Ed25519 precompile message must not be empty');
-    }
-    const HEADER_SIZE = 16;
-    const totalSize = HEADER_SIZE + 64 + 32 + message.length;
-    const instructionData = new Uint8Array(totalSize);
-    instructionData[0] = 1;
-    instructionData[1] = 0;
-    const sigOffset = HEADER_SIZE;
-    const pkOffset = sigOffset + 64;
-    const msgOffset = pkOffset + 32;
-    instructionData[2] = sigOffset & 0xff;
-    instructionData[3] = (sigOffset >> 8) & 0xff;
-    instructionData[4] = 0xff;
-    instructionData[5] = 0xff;
-    instructionData[6] = pkOffset & 0xff;
-    instructionData[7] = (pkOffset >> 8) & 0xff;
-    instructionData[8] = 0xff;
-    instructionData[9] = 0xff;
-    instructionData[10] = msgOffset & 0xff;
-    instructionData[11] = (msgOffset >> 8) & 0xff;
-    instructionData[12] = message.length & 0xff;
-    instructionData[13] = (message.length >> 8) & 0xff;
-    instructionData[14] = 0xff;
-    instructionData[15] = 0xff;
-    instructionData.set(signature, sigOffset);
-    instructionData.set(pubkey, pkOffset);
-    instructionData.set(message, msgOffset);
-    return {
-        programAddress: ED25519_PROGRAM,
-        accounts: [],
-        data: instructionData,
-    };
-}
-class SolanaPaymentChannelSDK {
-    _rpc;
-    _rpcSubscriptions;
-    _programId;
-    _logger;
-    constructor(rpcUrl, programId, logger) {
-        this._programId = (0, kit_1.address)(programId);
-        this._logger = logger.child({ component: 'solana-payment-channel-sdk' });
-        this._rpc = (0, kit_1.createSolanaRpc)(rpcUrl);
-        this._rpcSubscriptions = (0, kit_1.createSolanaRpcSubscriptions)(rpcUrl.replace('http', 'ws'));
-    }
-    static deriveChannelPDA(participantA, participantB, tokenMint, programId) {
-        const addrA = (0, kit_1.address)(participantA);
-        const addrB = (0, kit_1.address)(participantB);
-        const mint = (0, kit_1.address)(tokenMint);
-        const program = (0, kit_1.address)(programId);
-        const [min, max] = sortParticipants(addrA, addrB);
-        const encoder = (0, kit_1.getAddressEncoder)();
-        const seeds = [
-            new TextEncoder().encode('channel'),
-            toMutableBytes(encoder.encode(min)),
-            toMutableBytes(encoder.encode(max)),
-            toMutableBytes(encoder.encode(mint)),
-        ];
-        const pdaResult = findProgramDerivedAddressSync(seeds, program);
-        return { pda: pdaResult[0], bump: pdaResult[1] };
-    }
-    static deriveVaultPDA(channelPDA, programId) {
-        const channel = (0, kit_1.address)(channelPDA);
-        const program = (0, kit_1.address)(programId);
-        const encoder = (0, kit_1.getAddressEncoder)();
-        const seeds = [
-            new TextEncoder().encode('vault'),
-            toMutableBytes(encoder.encode(channel)),
-        ];
-        const pdaResult = findProgramDerivedAddressSync(seeds, program);
-        return { pda: pdaResult[0], bump: pdaResult[1] };
-    }
-    static _buildBalanceProofMessage(channelPDA, nonce, transferredAmount) {
-        const message = new Uint8Array(48);
-        const encoder = (0, kit_1.getAddressEncoder)();
-        const pdaBytes = toMutableBytes(encoder.encode((0, kit_1.address)(channelPDA)));
-        message.set(pdaBytes, 0);
-        writeUint64LE(message, 32, nonce);
-        writeUint64LE(message, 40, transferredAmount);
-        return message;
-    }
-    static async signBalanceProof(channelPDA, nonce, transferredAmount, keypair) {
-        const message = SolanaPaymentChannelSDK._buildBalanceProofMessage(channelPDA, nonce, transferredAmount);
-        const signature = await (0, kit_1.signBytes)(keypair.privateKey, message);
-        return new Uint8Array(signature);
-    }
-    async openChannel(payer, participantA, participantB, tokenMint, challengeDuration) {
-        this._logger.info({
-            event: 'open_channel_start',
-            participantA,
-            participantB,
-            tokenMint,
-            challengeDuration: challengeDuration.toString(),
-        }, 'Opening Solana payment channel');
-        const { pda: channelPDA } = SolanaPaymentChannelSDK.deriveChannelPDA(participantA, participantB, tokenMint, this._programId);
-        const { pda: vaultPDA } = SolanaPaymentChannelSDK.deriveVaultPDA(channelPDA, this._programId);
-        const instructionData = new Uint8Array(16);
-        instructionData.set(DISCRIMINATORS.INITIALIZE_CHANNEL, 0);
-        writeUint64LE(instructionData, 8, challengeDuration);
-        const accounts = [
-            { address: payer.address, role: kit_1.AccountRole.WRITABLE_SIGNER },
-            { address: (0, kit_1.address)(participantA), role: kit_1.AccountRole.READONLY },
-            { address: (0, kit_1.address)(participantB), role: kit_1.AccountRole.READONLY },
-            { address: (0, kit_1.address)(tokenMint), role: kit_1.AccountRole.READONLY },
-            { address: (0, kit_1.address)(channelPDA), role: kit_1.AccountRole.WRITABLE },
-            { address: (0, kit_1.address)(vaultPDA), role: kit_1.AccountRole.WRITABLE },
-            { address: SYSTEM_PROGRAM, role: kit_1.AccountRole.READONLY },
-            { address: TOKEN_PROGRAM, role: kit_1.AccountRole.READONLY },
-            { address: RENT_SYSVAR, role: kit_1.AccountRole.READONLY },
-        ];
-        const instruction = {
-            programAddress: this._programId,
-            accounts,
-            data: instructionData,
-        };
-        try {
-            const txSignature = await this._sendTransaction(payer, [instruction]);
-            this._logger.info({
-                event: 'open_channel_success',
-                channelPDA,
-                txSignature,
-            }, 'Solana payment channel opened');
-            return { channelPDA, txSignature };
-        }
-        catch (err) {
-            this._logger.error({ event: 'open_channel_error', error: String(err) }, 'Failed to open Solana payment channel');
-            parseSolanaError(err);
-        }
-    }
-    async deposit(depositor, channelPDA, depositorTokenAccount, amount) {
-        this._logger.info({
-            event: 'deposit_start',
-            channelPDA,
-            amount: amount.toString(),
-        }, 'Depositing to Solana payment channel');
-        const { pda: vaultPDA } = SolanaPaymentChannelSDK.deriveVaultPDA(channelPDA, this._programId);
-        const instructionData = new Uint8Array(16);
-        instructionData.set(DISCRIMINATORS.DEPOSIT, 0);
-        writeUint64LE(instructionData, 8, amount);
-        const accounts = [
-            { address: depositor.address, role: kit_1.AccountRole.READONLY_SIGNER },
-            { address: (0, kit_1.address)(depositorTokenAccount), role: kit_1.AccountRole.WRITABLE },
-            { address: (0, kit_1.address)(vaultPDA), role: kit_1.AccountRole.WRITABLE },
-            { address: (0, kit_1.address)(channelPDA), role: kit_1.AccountRole.WRITABLE },
-            { address: TOKEN_PROGRAM, role: kit_1.AccountRole.READONLY },
-        ];
-        const instruction = {
-            programAddress: this._programId,
-            accounts,
-            data: instructionData,
-        };
-        try {
-            const txSignature = await this._sendTransaction(depositor, [instruction]);
-            this._logger.info({ event: 'deposit_success', channelPDA, txSignature }, 'Deposit to Solana payment channel succeeded');
-            return { txSignature };
-        }
-        catch (err) {
-            this._logger.error({ event: 'deposit_error', error: String(err) }, 'Failed to deposit to Solana payment channel');
-            parseSolanaError(err);
-        }
-    }
-    async claimFromChannel(claimer, channelPDA, nonce, transferredAmount, signature) {
-        this._logger.info({
-            event: 'claim_start',
-            channelPDA,
-            nonce: nonce.toString(),
-            transferredAmount: transferredAmount.toString(),
-        }, 'Claiming from Solana payment channel');
-        const encoder = (0, kit_1.getAddressEncoder)();
-        const claimerPubkey = toMutableBytes(encoder.encode(claimer.address));
-        const balanceProofMessage = SolanaPaymentChannelSDK._buildBalanceProofMessage(channelPDA, nonce, transferredAmount);
-        const ed25519Instruction = buildEd25519PrecompileInstruction(signature, claimerPubkey, balanceProofMessage);
-        const claimData = new Uint8Array(24);
-        claimData.set(DISCRIMINATORS.CLAIM_FROM_CHANNEL, 0);
-        writeUint64LE(claimData, 8, nonce);
-        writeUint64LE(claimData, 16, transferredAmount);
-        const claimAccounts = [
-            { address: claimer.address, role: kit_1.AccountRole.READONLY_SIGNER },
-            { address: (0, kit_1.address)(channelPDA), role: kit_1.AccountRole.WRITABLE },
-            { address: INSTRUCTIONS_SYSVAR, role: kit_1.AccountRole.READONLY },
-        ];
-        const claimInstruction = {
-            programAddress: this._programId,
-            accounts: claimAccounts,
-            data: claimData,
-        };
-        try {
-            const txSignature = await this._sendTransaction(claimer, [
-                ed25519Instruction,
-                claimInstruction,
-            ]);
-            this._logger.info({ event: 'claim_success', channelPDA, txSignature }, 'Claim from Solana payment channel succeeded');
-            return { txSignature };
-        }
-        catch (err) {
-            this._logger.error({ event: 'claim_error', error: String(err) }, 'Failed to claim from Solana payment channel');
-            parseSolanaError(err);
-        }
-    }
-    async closeChannel(closer, channelPDA) {
-        this._logger.info({ event: 'close_channel_start', channelPDA }, 'Closing Solana payment channel');
-        const accounts = [
-            { address: closer.address, role: kit_1.AccountRole.READONLY_SIGNER },
-            { address: (0, kit_1.address)(channelPDA), role: kit_1.AccountRole.WRITABLE },
-            { address: CLOCK_SYSVAR, role: kit_1.AccountRole.READONLY },
-        ];
-        const instruction = {
-            programAddress: this._programId,
-            accounts,
-            data: DISCRIMINATORS.CLOSE_CHANNEL,
-        };
-        try {
-            const txSignature = await this._sendTransaction(closer, [instruction]);
-            this._logger.info({ event: 'close_channel_success', channelPDA, txSignature }, 'Solana payment channel closed');
-            return { txSignature };
-        }
-        catch (err) {
-            this._logger.error({ event: 'close_channel_error', error: String(err) }, 'Failed to close Solana payment channel');
-            parseSolanaError(err);
-        }
-    }
-    async settleChannel(caller, channelPDA, participantAToken, participantBToken, rentRecipient) {
-        this._logger.info({ event: 'settle_channel_start', channelPDA }, 'Settling Solana payment channel');
-        const { pda: vaultPDA } = SolanaPaymentChannelSDK.deriveVaultPDA(channelPDA, this._programId);
-        const accounts = [
-            { address: caller.address, role: kit_1.AccountRole.READONLY_SIGNER },
-            { address: (0, kit_1.address)(channelPDA), role: kit_1.AccountRole.WRITABLE },
-            { address: (0, kit_1.address)(vaultPDA), role: kit_1.AccountRole.WRITABLE },
-            { address: (0, kit_1.address)(participantAToken), role: kit_1.AccountRole.WRITABLE },
-            { address: (0, kit_1.address)(participantBToken), role: kit_1.AccountRole.WRITABLE },
-            { address: (0, kit_1.address)(rentRecipient), role: kit_1.AccountRole.WRITABLE },
-            { address: TOKEN_PROGRAM, role: kit_1.AccountRole.READONLY },
-            { address: CLOCK_SYSVAR, role: kit_1.AccountRole.READONLY },
-        ];
-        const instruction = {
-            programAddress: this._programId,
-            accounts,
-            data: DISCRIMINATORS.SETTLE_CHANNEL,
-        };
-        try {
-            const txSignature = await this._sendTransaction(caller, [instruction]);
-            this._logger.info({ event: 'settle_channel_success', channelPDA, txSignature }, 'Solana payment channel settled');
-            return { txSignature };
-        }
-        catch (err) {
-            this._logger.error({ event: 'settle_channel_error', error: String(err) }, 'Failed to settle Solana payment channel');
-            parseSolanaError(err);
-        }
-    }
-    async forceCloseExpired(caller, channelPDA, participantAToken, participantBToken, rentRecipient) {
-        this._logger.info({ event: 'force_close_start', channelPDA }, 'Force closing expired Solana payment channel');
-        const { pda: vaultPDA } = SolanaPaymentChannelSDK.deriveVaultPDA(channelPDA, this._programId);
-        const accounts = [
-            { address: caller.address, role: kit_1.AccountRole.READONLY_SIGNER },
-            { address: (0, kit_1.address)(channelPDA), role: kit_1.AccountRole.WRITABLE },
-            { address: (0, kit_1.address)(vaultPDA), role: kit_1.AccountRole.WRITABLE },
-            { address: (0, kit_1.address)(participantAToken), role: kit_1.AccountRole.WRITABLE },
-            { address: (0, kit_1.address)(participantBToken), role: kit_1.AccountRole.WRITABLE },
-            { address: (0, kit_1.address)(rentRecipient), role: kit_1.AccountRole.WRITABLE },
-            { address: TOKEN_PROGRAM, role: kit_1.AccountRole.READONLY },
-            { address: CLOCK_SYSVAR, role: kit_1.AccountRole.READONLY },
-        ];
-        const instruction = {
-            programAddress: this._programId,
-            accounts,
-            data: DISCRIMINATORS.FORCE_CLOSE_EXPIRED,
-        };
-        try {
-            const txSignature = await this._sendTransaction(caller, [instruction]);
-            this._logger.info({ event: 'force_close_success', channelPDA, txSignature }, 'Force close expired Solana payment channel succeeded');
-            return { txSignature };
-        }
-        catch (err) {
-            this._logger.error({ event: 'force_close_error', error: String(err) }, 'Failed to force close expired Solana payment channel');
-            parseSolanaError(err);
-        }
-    }
-    async getMintMetadata(mintAddress) {
-        const fallback = { assetCode: mintAddress, assetScale: 0 };
-        try {
-            const accountInfo = await this._rpc
-                .getAccountInfo((0, kit_1.address)(mintAddress), { encoding: 'jsonParsed' })
-                .send();
-            if (!accountInfo.value) {
-                this._logger.warn({ event: 'spl_mint_not_found', mintAddress }, 'SPL mint account not found on-chain; using raw-address fallback');
-                return fallback;
-            }
-            const data = accountInfo.value.data;
-            if (data &&
-                typeof data === 'object' &&
-                'parsed' in data &&
-                data.parsed &&
-                typeof data.parsed === 'object' &&
-                'info' in data.parsed &&
-                data.parsed.info &&
-                typeof data.parsed.info === 'object' &&
-                'decimals' in data.parsed.info &&
-                typeof data.parsed.info.decimals === 'number') {
-                const decimals = data.parsed.info.decimals;
-                return { assetCode: mintAddress, assetScale: decimals };
-            }
-            this._logger.warn({ event: 'spl_mint_unparseable', mintAddress }, 'SPL mint account parsed data missing decimals; using raw-address fallback');
-            return fallback;
-        }
-        catch (err) {
-            this._logger.warn({
-                event: 'spl_mint_rpc_failed',
-                mintAddress,
-                error: err instanceof Error ? err.message : String(err),
-            }, 'SPL mint RPC lookup failed; using raw-address fallback');
-            return fallback;
-        }
-    }
-    async getChannelState(channelPDA) {
-        this._logger.debug({ event: 'get_channel_state', channelPDA }, 'Fetching Solana channel state');
-        const accountInfo = await this._rpc
-            .getAccountInfo((0, kit_1.address)(channelPDA), { encoding: 'base64' })
-            .send();
-        if (!accountInfo.value) {
-            throw new Error(`Channel account not found: ${channelPDA}`);
-        }
-        const data = accountInfo.value.data;
-        let rawBytes;
-        if (Array.isArray(data)) {
-            const base64Str = data[0];
-            rawBytes = Uint8Array.from(Buffer.from(base64Str, 'base64'));
-        }
-        else if (data instanceof Uint8Array) {
-            rawBytes = data;
-        }
-        else {
-            throw new Error(`Unexpected account data format for ${channelPDA}`);
-        }
-        return deserializeChannelState(rawBytes);
-    }
-    subscribeToChannel(channelPDA, callback) {
-        const abortController = new AbortController();
-        this._logger.info({ event: 'subscribe_channel', channelPDA }, 'Subscribing to Solana channel account changes');
-        void this._runSubscriptionLoop(channelPDA, callback, abortController.signal);
-        return {
-            unsubscribe: () => {
-                this._logger.info({ event: 'unsubscribe_channel', channelPDA }, 'Unsubscribing from Solana channel account changes');
-                abortController.abort();
-            },
-        };
-    }
-    async _runSubscriptionLoop(channelPDA, callback, signal) {
-        try {
-            const notifications = await this._rpcSubscriptions
-                .accountNotifications((0, kit_1.address)(channelPDA), { commitment: 'confirmed' })
-                .subscribe({ abortSignal: signal });
-            for await (const notification of notifications) {
-                try {
-                    const notificationValue = notification;
-                    const data = notificationValue.value?.data;
-                    let rawBytes;
-                    if (Array.isArray(data)) {
-                        const base64Str = data[0];
-                        rawBytes = Uint8Array.from(Buffer.from(base64Str, 'base64'));
-                    }
-                    else if (data instanceof Uint8Array) {
-                        rawBytes = data;
-                    }
-                    else {
-                        this._logger.warn({ event: 'subscription_data_format_unknown', channelPDA }, 'Unknown account data format in subscription notification');
-                        continue;
-                    }
-                    const state = deserializeChannelState(rawBytes);
-                    callback(state);
-                }
-                catch (deserError) {
-                    this._logger.warn({
-                        event: 'subscription_deserialize_error',
-                        channelPDA,
-                        error: String(deserError),
-                    }, 'Failed to deserialize channel state from subscription notification');
-                }
-            }
-        }
-        catch (err) {
-            if (signal.aborted) {
-                return;
-            }
-            this._logger.error({ event: 'subscription_error', channelPDA, error: String(err) }, 'Subscription loop failed');
-        }
-    }
-    async _sendTransaction(feePayer, instructions) {
-        const { value: latestBlockhash } = await this._rpc.getLatestBlockhash().send();
-        const txMessage = (0, kit_1.pipe)((0, kit_1.createTransactionMessage)({ version: 0 }), (m) => (0, kit_1.setTransactionMessageFeePayerSigner)(feePayer, m), (m) => (0, kit_1.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, m), (m) => instructions.reduce((msg, ix) => (0, kit_1.appendTransactionMessageInstruction)(ix, msg), m));
-        const signatureBytes = await (0, kit_1.signAndSendTransactionMessageWithSigners)(txMessage);
-        const base58Decoder = (0, kit_1.getBase58Decoder)();
-        return base58Decoder.decode(signatureBytes);
-    }
-}
-exports.SolanaPaymentChannelSDK = SolanaPaymentChannelSDK;
-function findProgramDerivedAddressSync(seeds, programId) {
-    const encoder = (0, kit_1.getAddressEncoder)();
-    const decoder = (0, kit_1.getAddressDecoder)();
-    const programIdBytes = toMutableBytes(encoder.encode(programId));
-    const PDA_MARKER = new TextEncoder().encode('ProgramDerivedAddress');
-    for (let bump = 255; bump >= 0; bump--) {
-        const bumpSeed = new Uint8Array([bump]);
-        const allSeeds = [...seeds, bumpSeed];
-        let totalLen = 0;
-        for (const s of allSeeds) {
-            totalLen += s.length;
-        }
-        totalLen += programIdBytes.length + PDA_MARKER.length;
-        const hashInput = new Uint8Array(totalLen);
-        let offset = 0;
-        for (const s of allSeeds) {
-            hashInput.set(s, offset);
-            offset += s.length;
-        }
-        hashInput.set(programIdBytes, offset);
-        offset += programIdBytes.length;
-        hashInput.set(PDA_MARKER, offset);
-        const hash = crypto.createHash('sha256').update(hashInput).digest();
-        const hashBytes = new Uint8Array(hash);
-        if (!isOnCurve(hashBytes)) {
-            const pdaAddress = decoder.decode(hashBytes);
-            return [pdaAddress, bump];
-        }
-    }
-    throw new Error('Could not find a viable PDA bump seed');
-}
-function isOnCurve(bytes) {
-    const P = (1n << 255n) - 19n;
-    const yBytes = new Uint8Array(32);
-    yBytes.set(bytes);
-    yBytes[31] = (yBytes[31] ?? 0) & 0x7f;
-    let y = 0n;
-    for (let i = 0; i < 32; i++) {
-        y |= BigInt(yBytes[i] ?? 0) << BigInt(i * 8);
-    }
-    if (y >= P) {
-        return false;
-    }
-    const D = modP(-121665n * modInverse(121666n, P), P);
-    const y2 = modP(y * y, P);
-    const u = modP(y2 - 1n, P);
-    const v = modP(D * y2 + 1n, P);
-    const vInv = modInverse(v, P);
-    const ratio = modP(u * vInv, P);
-    const euler = modPow(ratio, (P - 1n) / 2n, P);
-    return euler === 0n || euler === 1n;
-}
-function modP(a, p) {
-    return ((a % p) + p) % p;
-}
-function modInverse(a, p) {
-    return modPow(modP(a, p), p - 2n, p);
-}
-function modPow(base, exp, modulus) {
-    let result = 1n;
-    base = modP(base, modulus);
-    while (exp > 0n) {
-        if (exp & 1n) {
-            result = modP(result * base, modulus);
-        }
-        exp >>= 1n;
-        base = modP(base * base, modulus);
-    }
-    return result;
-}
-//# sourceMappingURL=solana-payment-channel-sdk.js.map