@yellow-org/sdk 1.0.1-alpha.0

package/dist/client.js

@@ -0,0 +1,720 @@
+import { createPublicClient, createWalletClient, http, custom, verifyMessage } from 'viem';
+import * as core from './core';
+import * as app from './app';
+import { RPCClient } from './rpc/client';
+import { WebsocketDialer } from './rpc/dialer';
+import { ClientAssetStore } from './asset_store';
+import { DefaultConfig } from './config';
+import { generateNonce, transformNodeConfig, transformAssets, transformBalances, transformChannel, transformState, transformTransaction, transformPaginationMetadata, transformAppDefinitionToRPC, transformAppStateUpdateToRPC, transformSignedAppStateUpdateToRPC, transformAppSessionInfo, transformAppDefinitionFromRPC, } from './utils';
+import * as blockchain from './blockchain';
+import { nextState, applyChannelCreation, applyAcknowledgementTransition, applyHomeDepositTransition, applyHomeWithdrawalTransition, applyTransferSendTransition, applyFinalizeTransition, applyCommitTransition } from './core/state';
+import { newVoidState } from './core/types';
+import { packState, packChallengeState } from './core/state_packer';
+export const DEFAULT_CHALLENGE_PERIOD = 86400;
+function stripSignerTypePrefix(sig) {
+    if (sig.length < 6) {
+        throw new Error(`signature too short to contain a signer type prefix: ${sig}`);
+    }
+    const prefixByte = parseInt(sig.slice(2, 4), 16);
+    if (prefixByte !== core.ChannelSignerType.Default) {
+        throw new Error(`expected ChannelDefaultSigner prefix 0x00, got 0x${prefixByte.toString(16).padStart(2, '0')}; ` +
+            `session key signing requires the default wallet signer, not a session key signer`);
+    }
+    return `0x${sig.slice(4)}`;
+}
+export class Client {
+    constructor(rpcClient, config, stateSigner, txSigner, assetStore) {
+        this.rpcClient = rpcClient;
+        this.config = config;
+        this.stateSigner = stateSigner;
+        this.txSigner = txSigner;
+        this.assetStore = assetStore;
+        this.blockchainClients = new Map();
+        this.homeBlockchains = new Map();
+        this.exitPromise = new Promise((resolve) => {
+            this.exitResolve = resolve;
+        });
+    }
+    static async create(wsURL, stateSigner, txSigner, ...opts) {
+        const config = {
+            url: wsURL,
+            handshakeTimeout: DefaultConfig.handshakeTimeout,
+            pingInterval: DefaultConfig.pingInterval,
+            errorHandler: DefaultConfig.errorHandler,
+            blockchainRPCs: DefaultConfig.blockchainRPCs || new Map(),
+        };
+        for (const opt of opts) {
+            opt(config);
+        }
+        const dialer = new WebsocketDialer();
+        const rpcClient = new RPCClient(dialer);
+        let client;
+        const assetStore = new ClientAssetStore(async () => {
+            return await client.getAssets();
+        });
+        client = new Client(rpcClient, config, stateSigner, txSigner, assetStore);
+        const handleError = (err) => {
+            if (err && config.errorHandler) {
+                config.errorHandler(err);
+            }
+            client.exitResolve?.();
+        };
+        await rpcClient.start(wsURL, handleError);
+        return client;
+    }
+    async setHomeBlockchain(asset, blockchainId) {
+        const existingBlockchainId = this.homeBlockchains.get(asset);
+        if (existingBlockchainId !== undefined) {
+            throw new Error(`home blockchain is already set for asset ${asset} to ${existingBlockchainId}, please use Migrate() if you want to change home blockchain`);
+        }
+        const exists = await this.assetStore.assetExistsOnBlockchain(blockchainId, asset);
+        if (!exists) {
+            throw new Error(`asset ${asset} not supported on blockchain ${blockchainId}`);
+        }
+        this.homeBlockchains.set(asset, blockchainId);
+    }
+    async close() {
+        this.exitResolve?.();
+    }
+    waitForClose() {
+        return this.exitPromise;
+    }
+    async signState(state) {
+        const packed = await packState(state, this.assetStore);
+        const signature = await this.stateSigner.signMessage(packed);
+        return signature;
+    }
+    getUserAddress() {
+        return this.stateSigner.getAddress();
+    }
+    async signAndSubmitState(state) {
+        const sig = await this.signState(state);
+        state.userSig = sig;
+        const nodeSig = await this.submitState(state);
+        state.nodeSig = nodeSig;
+        return nodeSig;
+    }
+    async deposit(blockchainId, asset, amount) {
+        const userWallet = this.getUserAddress();
+        const nodeAddress = await this.getNodeAddress();
+        if (!nodeAddress) {
+            throw new Error('node address is undefined - ensure node config is properly loaded');
+        }
+        const tokenAddress = await this.assetStore.getTokenAddress(asset, blockchainId);
+        if (!tokenAddress) {
+            throw new Error(`token address not found for asset ${asset} on blockchain ${blockchainId}`);
+        }
+        let state = null;
+        let channelIsOpen = false;
+        try {
+            state = await this.getLatestState(userWallet, asset, false);
+            if (state && state.homeChannelId) {
+                const hasFinalize = state.transition.type === core.TransitionType.Finalize;
+                channelIsOpen = !hasFinalize;
+            }
+        }
+        catch (err) {
+        }
+        if (!state || !state.homeChannelId || !channelIsOpen) {
+            const bitmap = await this.getSupportedSigValidatorsBitmap();
+            const channelDef = {
+                nonce: generateNonce(),
+                challenge: DEFAULT_CHALLENGE_PERIOD,
+                approvedSigValidators: bitmap,
+            };
+            if (!state) {
+                state = newVoidState(asset, userWallet);
+            }
+            const newState = nextState(state);
+            applyChannelCreation(newState, channelDef, blockchainId, tokenAddress, nodeAddress);
+            applyHomeDepositTransition(newState, amount);
+            const sig = await this.signState(newState);
+            newState.userSig = sig;
+            const nodeSig = await this.requestChannelCreation(newState, channelDef);
+            newState.nodeSig = nodeSig;
+            return newState;
+        }
+        const newState = nextState(state);
+        applyHomeDepositTransition(newState, amount);
+        await this.signAndSubmitState(newState);
+        return newState;
+    }
+    async withdraw(blockchainId, asset, amount) {
+        const userWallet = this.getUserAddress();
+        const nodeAddress = await this.getNodeAddress();
+        if (!nodeAddress) {
+            throw new Error('node address is undefined - ensure node config is properly loaded');
+        }
+        const tokenAddress = await this.assetStore.getTokenAddress(asset, blockchainId);
+        if (!tokenAddress) {
+            throw new Error(`token address not found for asset ${asset} on blockchain ${blockchainId}`);
+        }
+        let state = null;
+        let channelIsOpen = false;
+        try {
+            state = await this.getLatestState(userWallet, asset, false);
+            if (state && state.homeChannelId) {
+                const hasFinalize = state.transition.type === core.TransitionType.Finalize;
+                channelIsOpen = !hasFinalize;
+            }
+        }
+        catch (err) {
+        }
+        if (!state || !state.homeChannelId || !channelIsOpen) {
+            const bitmap = await this.getSupportedSigValidatorsBitmap();
+            const channelDef = {
+                nonce: generateNonce(),
+                challenge: DEFAULT_CHALLENGE_PERIOD,
+                approvedSigValidators: bitmap,
+            };
+            if (!state) {
+                state = newVoidState(asset, userWallet);
+            }
+            const newState = nextState(state);
+            applyChannelCreation(newState, channelDef, blockchainId, tokenAddress, nodeAddress);
+            applyHomeWithdrawalTransition(newState, amount);
+            const sig = await this.signState(newState);
+            newState.userSig = sig;
+            const nodeSig = await this.requestChannelCreation(newState, channelDef);
+            newState.nodeSig = nodeSig;
+            return newState;
+        }
+        const newState = nextState(state);
+        applyHomeWithdrawalTransition(newState, amount);
+        await this.signAndSubmitState(newState);
+        return newState;
+    }
+    async transfer(recipientWallet, asset, amount) {
+        const senderWallet = this.getUserAddress();
+        let state = null;
+        try {
+            state = await this.getLatestState(senderWallet, asset, false);
+        }
+        catch (err) {
+        }
+        if (!state || !state.homeChannelId) {
+            const bitmap = await this.getSupportedSigValidatorsBitmap();
+            const channelDef = {
+                nonce: generateNonce(),
+                challenge: DEFAULT_CHALLENGE_PERIOD,
+                approvedSigValidators: bitmap,
+            };
+            if (!state) {
+                state = newVoidState(asset, senderWallet);
+            }
+            const newState = nextState(state);
+            let blockchainId = this.homeBlockchains.get(asset);
+            if (!blockchainId) {
+                if (state.homeLedger.blockchainId !== 0n) {
+                    blockchainId = state.homeLedger.blockchainId;
+                }
+                else {
+                    blockchainId = await this.assetStore.getSuggestedBlockchainId(asset);
+                }
+            }
+            const nodeAddress = await this.getNodeAddress();
+            if (!nodeAddress) {
+                throw new Error('node address is undefined - ensure node config is properly loaded');
+            }
+            const tokenAddress = await this.assetStore.getTokenAddress(asset, blockchainId);
+            if (!tokenAddress) {
+                throw new Error(`token address not found for asset ${asset} on blockchain ${blockchainId}`);
+            }
+            applyChannelCreation(newState, channelDef, blockchainId, tokenAddress, nodeAddress);
+            applyTransferSendTransition(newState, recipientWallet, amount);
+            const sig = await this.signState(newState);
+            newState.userSig = sig;
+            const nodeSig = await this.requestChannelCreation(newState, channelDef);
+            newState.nodeSig = nodeSig;
+            return newState;
+        }
+        const newState = nextState(state);
+        applyTransferSendTransition(newState, recipientWallet, amount);
+        await this.signAndSubmitState(newState);
+        return newState;
+    }
+    async acknowledge(asset) {
+        const userWallet = this.getUserAddress();
+        let state = null;
+        try {
+            state = await this.getLatestState(userWallet, asset, false);
+        }
+        catch (err) {
+        }
+        if (!state || !state.homeChannelId) {
+            const bitmap = await this.getSupportedSigValidatorsBitmap();
+            const channelDef = {
+                nonce: generateNonce(),
+                challenge: DEFAULT_CHALLENGE_PERIOD,
+                approvedSigValidators: bitmap,
+            };
+            if (!state) {
+                state = newVoidState(asset, userWallet);
+            }
+            const newState = nextState(state);
+            let blockchainId = this.homeBlockchains.get(asset);
+            if (!blockchainId) {
+                if (state.homeLedger.blockchainId !== 0n) {
+                    blockchainId = state.homeLedger.blockchainId;
+                }
+                else {
+                    blockchainId = await this.assetStore.getSuggestedBlockchainId(asset);
+                }
+            }
+            const nodeAddress = await this.getNodeAddress();
+            if (!nodeAddress) {
+                throw new Error('node address is undefined - ensure node config is properly loaded');
+            }
+            const tokenAddress = await this.assetStore.getTokenAddress(asset, blockchainId);
+            if (!tokenAddress) {
+                throw new Error(`token address not found for asset ${asset} on blockchain ${blockchainId}`);
+            }
+            applyChannelCreation(newState, channelDef, blockchainId, tokenAddress, nodeAddress);
+            applyAcknowledgementTransition(newState);
+            const sig = await this.signState(newState);
+            newState.userSig = sig;
+            const nodeSig = await this.requestChannelCreation(newState, channelDef);
+            newState.nodeSig = nodeSig;
+            return newState;
+        }
+        if (state.userSig) {
+            throw new Error('state already acknowledged by user');
+        }
+        const newState = nextState(state);
+        applyAcknowledgementTransition(newState);
+        await this.signAndSubmitState(newState);
+        return newState;
+    }
+    async closeHomeChannel(asset) {
+        const senderWallet = this.getUserAddress();
+        const state = await this.getLatestState(senderWallet, asset, false);
+        if (!state.homeChannelId) {
+            throw new Error(`no channel exists for asset ${asset}`);
+        }
+        const newState = nextState(state);
+        applyFinalizeTransition(newState);
+        await this.signAndSubmitState(newState);
+        return newState;
+    }
+    async checkpoint(asset) {
+        const userWallet = this.getUserAddress();
+        const state = await this.getLatestState(userWallet, asset, true);
+        if (!state.homeChannelId) {
+            throw new Error(`no channel exists for asset ${asset}`);
+        }
+        const blockchainId = state.homeLedger.blockchainId;
+        await this.initializeBlockchainClient(blockchainId);
+        const blockchainClient = this.blockchainClients.get(blockchainId);
+        const channel = await this.getHomeChannel(userWallet, asset);
+        switch (state.transition.type) {
+            case core.TransitionType.Acknowledgement:
+            case core.TransitionType.HomeDeposit:
+            case core.TransitionType.HomeWithdrawal:
+            case core.TransitionType.TransferSend:
+            case core.TransitionType.TransferReceive:
+            case core.TransitionType.Commit:
+            case core.TransitionType.Release:
+                {
+                    if (channel.status === core.ChannelStatus.Void) {
+                        const channelDef = {
+                            nonce: channel.nonce,
+                            challenge: channel.challengeDuration,
+                            approvedSigValidators: channel.approvedSigValidators,
+                        };
+                        return await blockchainClient.create(channelDef, state);
+                    }
+                    return await blockchainClient.checkpoint(state);
+                }
+            case core.TransitionType.Finalize: {
+                return await blockchainClient.close(state);
+            }
+            default:
+                throw new Error(`transition type ${state.transition.type} does not require a blockchain operation`);
+        }
+    }
+    async challenge(state) {
+        if (!state.userSig || !state.nodeSig) {
+            throw new Error('state must have both user and node signatures');
+        }
+        if (!state.homeChannelId) {
+            throw new Error('state must have a home channel ID');
+        }
+        const packedState = await packState(state, this.assetStore);
+        const userSigRaw = `0x${state.userSig.slice(4)}`;
+        const userValid = await verifyMessage({
+            address: state.userWallet,
+            message: { raw: packedState },
+            signature: userSigRaw,
+        });
+        if (!userValid) {
+            throw new Error('invalid user signature');
+        }
+        const nodeAddress = await this.getNodeAddress();
+        const nodeSigRaw = `0x${state.nodeSig.slice(4)}`;
+        const nodeValid = await verifyMessage({
+            address: nodeAddress,
+            message: { raw: packedState },
+            signature: nodeSigRaw,
+        });
+        if (!nodeValid) {
+            throw new Error('invalid node signature');
+        }
+        const challengeData = await packChallengeState(state, this.assetStore);
+        const challengerSig = await this.stateSigner.signMessage(challengeData);
+        const blockchainId = state.homeLedger.blockchainId;
+        await this.initializeBlockchainClient(blockchainId);
+        const blockchainClient = this.blockchainClients.get(blockchainId);
+        return await blockchainClient.challenge(state, challengerSig);
+    }
+    async approveToken(chainId, asset, amount) {
+        await this.initializeBlockchainClient(chainId);
+        const blockchainClient = this.blockchainClients.get(chainId);
+        return await blockchainClient.approve(asset, amount);
+    }
+    async checkTokenAllowance(chainId, tokenAddress, owner) {
+        await this.initializeBlockchainClient(chainId);
+        const blockchainClient = this.blockchainClients.get(chainId);
+        return await blockchainClient.checkAllowanceByAddress(tokenAddress, owner);
+    }
+    async ping() {
+        await this.rpcClient.nodeV1Ping();
+    }
+    async getConfig() {
+        const resp = await this.rpcClient.nodeV1GetConfig();
+        return transformNodeConfig(resp);
+    }
+    async getBlockchains() {
+        const config = await this.getConfig();
+        return config.blockchains;
+    }
+    async getAssets(blockchainId) {
+        const req = {};
+        if (blockchainId !== undefined) {
+            req.blockchain_id = blockchainId;
+        }
+        const resp = await this.rpcClient.nodeV1GetAssets(req);
+        return transformAssets(resp.assets);
+    }
+    async getBalances(wallet) {
+        const req = {
+            wallet,
+        };
+        const resp = await this.rpcClient.userV1GetBalances(req);
+        return transformBalances(resp.balances);
+    }
+    async getTransactions(wallet, options) {
+        const req = {
+            wallet,
+            asset: options?.asset,
+            tx_type: options?.txType,
+            from_time: options?.fromTime,
+            to_time: options?.toTime,
+            pagination: options?.page && options?.pageSize ? {
+                offset: (options.page - 1) * options.pageSize,
+                limit: options.pageSize,
+            } : undefined,
+        };
+        const resp = await this.rpcClient.userV1GetTransactions(req);
+        return {
+            transactions: resp.transactions.map(transformTransaction),
+            metadata: transformPaginationMetadata(resp.metadata),
+        };
+    }
+    async getChannels(wallet, options) {
+        const req = {
+            wallet,
+            status: options?.status,
+            asset: options?.asset,
+            channel_type: options?.channelType,
+            pagination: options?.pagination
+                ? {
+                    offset: options.pagination.offset,
+                    limit: options.pagination.limit,
+                }
+                : undefined,
+        };
+        const resp = await this.rpcClient.channelsV1GetChannels(req);
+        return {
+            channels: resp.channels.map(transformChannel),
+            metadata: transformPaginationMetadata(resp.metadata),
+        };
+    }
+    async getHomeChannel(wallet, asset) {
+        const req = {
+            wallet,
+            asset,
+        };
+        const resp = await this.rpcClient.channelsV1GetHomeChannel(req);
+        return transformChannel(resp.channel);
+    }
+    async getEscrowChannel(escrowChannelId) {
+        const req = {
+            escrow_channel_id: escrowChannelId,
+        };
+        const resp = await this.rpcClient.channelsV1GetEscrowChannel(req);
+        return transformChannel(resp.channel);
+    }
+    async getLatestState(wallet, asset, onlySigned) {
+        const req = {
+            wallet,
+            asset,
+            only_signed: onlySigned,
+        };
+        const resp = await this.rpcClient.channelsV1GetLatestState(req);
+        return transformState(resp.state);
+    }
+    async getAppSessions(options) {
+        const req = {
+            app_session_id: options?.appSessionId,
+            participant: options?.wallet,
+            status: options?.status,
+            pagination: options?.page && options?.pageSize ? {
+                offset: (options.page - 1) * options.pageSize,
+                limit: options.pageSize,
+            } : undefined,
+        };
+        const resp = await this.rpcClient.appSessionsV1GetAppSessions(req);
+        return {
+            sessions: resp.app_sessions.map(transformAppSessionInfo),
+            metadata: transformPaginationMetadata(resp.metadata),
+        };
+    }
+    async getAppDefinition(appSessionId) {
+        const req = {
+            app_session_id: appSessionId,
+        };
+        const resp = await this.rpcClient.appSessionsV1GetAppDefinition(req);
+        return transformAppDefinitionFromRPC(resp.definition);
+    }
+    async createAppSession(definition, sessionData, quorumSigs) {
+        const req = {
+            definition: transformAppDefinitionToRPC(definition),
+            session_data: sessionData,
+            quorum_sigs: quorumSigs,
+        };
+        const resp = await this.rpcClient.appSessionsV1CreateAppSession(req);
+        return {
+            appSessionId: resp.app_session_id,
+            version: resp.version,
+            status: resp.status,
+        };
+    }
+    async submitAppSessionDeposit(appStateUpdate, quorumSigs, asset, depositAmount) {
+        const currentState = await this.getLatestState(this.getUserAddress(), asset, false);
+        const newState = nextState(currentState);
+        applyCommitTransition(newState, appStateUpdate.appSessionId, depositAmount);
+        const appUpdate = transformAppStateUpdateToRPC(appStateUpdate);
+        const stateSig = await this.signState(newState);
+        newState.userSig = stateSig;
+        const req = {
+            app_state_update: appUpdate,
+            quorum_sigs: quorumSigs,
+            user_state: this.transformStateToRPC(newState),
+        };
+        const resp = await this.rpcClient.appSessionsV1SubmitDepositState(req);
+        return resp.signature;
+    }
+    async submitAppState(appStateUpdate, quorumSigs) {
+        const appUpdate = transformAppStateUpdateToRPC(appStateUpdate);
+        const req = {
+            app_state_update: appUpdate,
+            quorum_sigs: quorumSigs,
+        };
+        await this.rpcClient.appSessionsV1SubmitAppState(req);
+    }
+    async rebalanceAppSessions(signedUpdates) {
+        const rpcUpdates = signedUpdates.map(transformSignedAppStateUpdateToRPC);
+        const req = {
+            signed_updates: rpcUpdates,
+        };
+        const resp = await this.rpcClient.appSessionsV1RebalanceAppSessions(req);
+        return resp.batch_id;
+    }
+    async signChannelSessionKeyState(state) {
+        const metadataHash = core.getChannelSessionKeyAuthMetadataHashV1(BigInt(state.version), state.assets, BigInt(state.expires_at));
+        const packed = core.packChannelKeyStateV1(state.session_key, metadataHash);
+        const channelSig = await this.stateSigner.signMessage(packed);
+        return stripSignerTypePrefix(channelSig);
+    }
+    async submitChannelSessionKeyState(state) {
+        const req = {
+            state,
+        };
+        await this.rpcClient.channelsV1SubmitSessionKeyState(req);
+    }
+    async getLastChannelKeyStates(userAddress, sessionKey) {
+        const req = {
+            user_address: userAddress,
+            session_key: sessionKey,
+        };
+        const resp = await this.rpcClient.channelsV1GetLastKeyStates(req);
+        return resp.states;
+    }
+    async signSessionKeyState(state) {
+        const packed = app.packAppSessionKeyStateV1(state);
+        const channelSig = await this.stateSigner.signMessage(packed);
+        return stripSignerTypePrefix(channelSig);
+    }
+    async submitSessionKeyState(state) {
+        const req = {
+            state,
+        };
+        await this.rpcClient.appSessionsV1SubmitSessionKeyState(req);
+    }
+    async getLastKeyStates(userAddress, sessionKey) {
+        const req = {
+            user_address: userAddress,
+            session_key: sessionKey,
+        };
+        const resp = await this.rpcClient.appSessionsV1GetLastKeyStates(req);
+        return resp.states;
+    }
+    async initializeBlockchainClient(chainId) {
+        if (this.blockchainClients.has(chainId)) {
+            return;
+        }
+        const rpcUrl = this.config.blockchainRPCs?.get(chainId);
+        if (!rpcUrl) {
+            throw new Error(`blockchain RPC not configured for chain ${chainId} (use withBlockchainRPC)`);
+        }
+        const config = await this.getConfig();
+        const blockchainInfo = config.blockchains.find((b) => b.id === chainId);
+        if (!blockchainInfo) {
+            throw new Error(`blockchain ${chainId} not supported by node`);
+        }
+        const contractAddress = blockchainInfo.channelHubAddress;
+        const nodeAddress = config.nodeAddress;
+        const publicClient = createPublicClient({
+            transport: http(rpcUrl),
+        });
+        const chain = {
+            id: Number(chainId),
+            name: `Chain ${chainId}`,
+            nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+            rpcUrls: {
+                default: { http: [rpcUrl] },
+                public: { http: [rpcUrl] },
+            },
+        };
+        const isBrowser = typeof window !== 'undefined' && typeof window.ethereum !== 'undefined';
+        let walletClient;
+        if (isBrowser) {
+            walletClient = createWalletClient({
+                chain,
+                transport: custom(window.ethereum),
+                account: this.txSigner.getAddress(),
+            });
+        }
+        else {
+            walletClient = createWalletClient({
+                chain,
+                transport: http(rpcUrl),
+                account: this.txSigner.getAddress(),
+            });
+        }
+        const blockchainClient = new blockchain.evm.Client(contractAddress, publicClient, walletClient, chainId, nodeAddress, this.assetStore);
+        this.blockchainClients.set(chainId, blockchainClient);
+    }
+    buildSigValidatorsBitmap(signerTypes) {
+        const bitmap = new Uint8Array(32);
+        for (const t of signerTypes) {
+            const idx = t & 0xff;
+            bitmap[31 - Math.floor(idx / 8)] |= 1 << (idx % 8);
+        }
+        for (let i = 0; i < 32; i++) {
+            if (bitmap[i] !== 0) {
+                const hex = Array.from(bitmap.slice(i))
+                    .map((b) => b.toString(16).padStart(2, '0'))
+                    .join('');
+                return '0x' + hex;
+            }
+        }
+        return '0x00';
+    }
+    async getSupportedSigValidatorsBitmap() {
+        const config = await this.getConfig();
+        return this.buildSigValidatorsBitmap(config.supportedSigValidators);
+    }
+    async getNodeAddress() {
+        const config = await this.getConfig();
+        return config.nodeAddress;
+    }
+    async submitState(state) {
+        const req = {
+            state: this.transformStateToRPC(state),
+        };
+        const resp = await this.rpcClient.channelsV1SubmitState(req);
+        return resp.signature;
+    }
+    async requestChannelCreation(state, channelDef) {
+        const req = {
+            state: this.transformStateToRPC(state),
+            channel_definition: this.transformChannelDefinitionToRPC(channelDef),
+        };
+        const resp = await this.rpcClient.channelsV1RequestCreation(req);
+        return resp.signature;
+    }
+    transformStateToRPC(state) {
+        return {
+            id: state.id,
+            transition: {
+                type: state.transition.type,
+                tx_id: state.transition.txId,
+                account_id: state.transition.accountId || '',
+                amount: state.transition.amount.toString(),
+            },
+            asset: state.asset,
+            user_wallet: state.userWallet,
+            epoch: state.epoch.toString(),
+            version: state.version.toString(),
+            home_channel_id: state.homeChannelId,
+            escrow_channel_id: state.escrowChannelId,
+            home_ledger: {
+                token_address: state.homeLedger.tokenAddress,
+                blockchain_id: state.homeLedger.blockchainId.toString(),
+                user_balance: state.homeLedger.userBalance.toString(),
+                user_net_flow: state.homeLedger.userNetFlow.toString(),
+                node_balance: state.homeLedger.nodeBalance.toString(),
+                node_net_flow: state.homeLedger.nodeNetFlow.toString(),
+            },
+            escrow_ledger: state.escrowLedger
+                ? {
+                    token_address: state.escrowLedger.tokenAddress,
+                    blockchain_id: state.escrowLedger.blockchainId.toString(),
+                    user_balance: state.escrowLedger.userBalance.toString(),
+                    user_net_flow: state.escrowLedger.userNetFlow.toString(),
+                    node_balance: state.escrowLedger.nodeBalance.toString(),
+                    node_net_flow: state.escrowLedger.nodeNetFlow.toString(),
+                }
+                : undefined,
+            user_sig: state.userSig,
+            node_sig: state.nodeSig,
+        };
+    }
+    transformChannelDefinitionToRPC(def) {
+        return {
+            nonce: def.nonce.toString(),
+            challenge: def.challenge,
+            approved_sig_validators: def.approvedSigValidators,
+        };
+    }
+    transitionTypeToString(type) {
+        const typeMap = {
+            [core.TransitionType.Void]: 'void',
+            [core.TransitionType.Acknowledgement]: 'acknowledgement',
+            [core.TransitionType.HomeDeposit]: 'home_deposit',
+            [core.TransitionType.HomeWithdrawal]: 'home_withdrawal',
+            [core.TransitionType.EscrowDeposit]: 'escrow_deposit',
+            [core.TransitionType.EscrowWithdraw]: 'escrow_withdraw',
+            [core.TransitionType.TransferSend]: 'transfer_send',
+            [core.TransitionType.TransferReceive]: 'transfer_receive',
+            [core.TransitionType.Commit]: 'commit',
+            [core.TransitionType.Release]: 'release',
+            [core.TransitionType.Migrate]: 'migrate',
+            [core.TransitionType.EscrowLock]: 'escrow_lock',
+            [core.TransitionType.MutualLock]: 'mutual_lock',
+            [core.TransitionType.Finalize]: 'finalize',
+        };
+        return typeMap[type] || 'home_deposit';
+    }
+}