@toon-protocol/connector 3.3.1 → 3.3.3

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

@@ -0,0 +1,636 @@
+"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