@yellow-org/sdk 1.0.1-alpha.0

package/dist/config.d.ts

@@ -0,0 +1,12 @@
+export interface Config {
+    url: string;
+    handshakeTimeout?: number;
+    errorHandler?: (error: Error) => void;
+    blockchainRPCs?: Map<bigint, string>;
+    pingInterval?: number;
+}
+export type Option = (config: Config) => void;
+export declare const DefaultConfig: Partial<Config>;
+export declare function withHandshakeTimeout(timeout: number): Option;
+export declare function withErrorHandler(handler: (error: Error) => void): Option;
+export declare function withBlockchainRPC(chainId: bigint, rpcUrl: string): Option;

package/dist/config.js

@@ -0,0 +1,28 @@
+function defaultErrorHandler(err) {
+    if (err) {
+        console.error('[nitrolite]', 'connection error:', err);
+    }
+}
+export const DefaultConfig = {
+    handshakeTimeout: 5000,
+    errorHandler: defaultErrorHandler,
+    blockchainRPCs: new Map(),
+};
+export function withHandshakeTimeout(timeout) {
+    return (config) => {
+        config.handshakeTimeout = timeout;
+    };
+}
+export function withErrorHandler(handler) {
+    return (config) => {
+        config.errorHandler = handler;
+    };
+}
+export function withBlockchainRPC(chainId, rpcUrl) {
+    return (config) => {
+        if (!config.blockchainRPCs) {
+            config.blockchainRPCs = new Map();
+        }
+        config.blockchainRPCs.set(chainId, rpcUrl);
+    };
+}

package/dist/core/event.d.ts

@@ -0,0 +1,29 @@
+import { Address, Hex } from 'viem';
+export interface ChannelEvent {
+    channelId: string;
+    stateVersion: bigint;
+}
+export interface ChannelChallengedEvent {
+    channelId: string;
+    stateVersion: bigint;
+    challengeExpiry: bigint;
+}
+export interface BlockchainEvent {
+    contractAddress: Address;
+    blockchainId: bigint;
+    name: string;
+    blockNumber: bigint;
+    transactionHash: Hex;
+    logIndex: number;
+}
+export type HomeChannelCreatedEvent = ChannelEvent;
+export type HomeChannelMigratedEvent = ChannelEvent;
+export type HomeChannelCheckpointedEvent = ChannelEvent;
+export type HomeChannelChallengedEvent = ChannelChallengedEvent;
+export type HomeChannelClosedEvent = ChannelEvent;
+export type EscrowDepositInitiatedEvent = ChannelEvent;
+export type EscrowDepositChallengedEvent = ChannelChallengedEvent;
+export type EscrowDepositFinalizedEvent = ChannelEvent;
+export type EscrowWithdrawalInitiatedEvent = ChannelEvent;
+export type EscrowWithdrawalChallengedEvent = ChannelChallengedEvent;
+export type EscrowWithdrawalFinalizedEvent = ChannelEvent;

package/dist/core/event.js

@@ -0,0 +1 @@
+export {};

package/dist/core/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './interface';
+export * from './event';
+export * from './utils';
+export * from './state';
+export * from './state_packer';

package/dist/core/index.js

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './interface';
+export * from './event';
+export * from './utils';
+export * from './state';
+export * from './state_packer';

package/dist/core/interface.d.ts

@@ -0,0 +1,53 @@
+import { Address, Hex } from 'viem';
+import Decimal from 'decimal.js';
+import { State, ChannelDefinition, HomeChannelDataResponse, EscrowDepositDataResponse, EscrowWithdrawalDataResponse } from './types';
+import { HomeChannelCreatedEvent, HomeChannelMigratedEvent, HomeChannelCheckpointedEvent, HomeChannelChallengedEvent, HomeChannelClosedEvent, EscrowDepositInitiatedEvent, EscrowDepositChallengedEvent, EscrowDepositFinalizedEvent, EscrowWithdrawalInitiatedEvent, EscrowWithdrawalChallengedEvent, EscrowWithdrawalFinalizedEvent } from './event';
+export interface Listener {
+    listen(): Promise<void>;
+}
+export interface Client {
+    getAccountsBalances(accounts: Address[], tokens: Address[]): Promise<Decimal[][]>;
+    getTokenBalance(asset: string, walletAddress: Address): Promise<Decimal>;
+    approve(asset: string, amount: Decimal): Promise<Hex>;
+    getNodeBalance(token: Address): Promise<Decimal>;
+    getOpenChannels(user: Address): Promise<string[]>;
+    getHomeChannelData(homeChannelId: string): Promise<HomeChannelDataResponse>;
+    getEscrowDepositData(escrowChannelId: string): Promise<EscrowDepositDataResponse>;
+    getEscrowWithdrawalData(escrowChannelId: string): Promise<EscrowWithdrawalDataResponse>;
+    deposit(node: Address, token: Address, amount: Decimal): Promise<Hex>;
+    withdraw(node: Address, token: Address, amount: Decimal): Promise<Hex>;
+    create(def: ChannelDefinition, initCCS: State): Promise<Hex>;
+    migrateChannelHere(def: ChannelDefinition, candidate: State): Promise<Hex>;
+    checkpoint(candidate: State): Promise<Hex>;
+    challenge(candidate: State, challengerSig: Uint8Array, challengerIdx: number): Promise<Hex>;
+    close(candidate: State): Promise<Hex>;
+    initiateEscrowDeposit(def: ChannelDefinition, initCCS: State): Promise<Hex>;
+    challengeEscrowDeposit(candidate: State, challengerSig: Uint8Array, challengerIdx: number): Promise<Hex>;
+    finalizeEscrowDeposit(candidate: State): Promise<Hex>;
+    initiateEscrowWithdrawal(def: ChannelDefinition, initCCS: State): Promise<Hex>;
+    challengeEscrowWithdrawal(candidate: State, challengerSig: Uint8Array, challengerIdx: number): Promise<Hex>;
+    finalizeEscrowWithdrawal(candidate: State): Promise<Hex>;
+}
+export interface StateAdvancer {
+    validateAdvancement(currentState: State, proposedState: State): Promise<void>;
+}
+export interface StatePacker {
+    packState(state: State): Promise<`0x${string}`>;
+}
+export interface AssetStore {
+    getAssetDecimals(asset: string): Promise<number>;
+    getTokenDecimals(blockchainId: bigint, tokenAddress: Address): Promise<number>;
+}
+export interface BlockchainEventHandler {
+    handleHomeChannelCreated(event: HomeChannelCreatedEvent): Promise<void>;
+    handleHomeChannelMigrated(event: HomeChannelMigratedEvent): Promise<void>;
+    handleHomeChannelCheckpointed(event: HomeChannelCheckpointedEvent): Promise<void>;
+    handleHomeChannelChallenged(event: HomeChannelChallengedEvent): Promise<void>;
+    handleHomeChannelClosed(event: HomeChannelClosedEvent): Promise<void>;
+    handleEscrowDepositInitiated(event: EscrowDepositInitiatedEvent): Promise<void>;
+    handleEscrowDepositChallenged(event: EscrowDepositChallengedEvent): Promise<void>;
+    handleEscrowDepositFinalized(event: EscrowDepositFinalizedEvent): Promise<void>;
+    handleEscrowWithdrawalInitiated(event: EscrowWithdrawalInitiatedEvent): Promise<void>;
+    handleEscrowWithdrawalChallenged(event: EscrowWithdrawalChallengedEvent): Promise<void>;
+    handleEscrowWithdrawalFinalized(event: EscrowWithdrawalFinalizedEvent): Promise<void>;
+}

package/dist/core/interface.js

@@ -0,0 +1 @@
+export {};

package/dist/core/state.d.ts

@@ -0,0 +1,21 @@
+import { Address } from 'viem';
+import Decimal from 'decimal.js';
+import { State, Transition, ChannelDefinition } from './types';
+export declare function getLastTransition(state: State): Transition | null;
+export declare function isFinal(state: State): boolean;
+export declare function nextState(state: State): State;
+export declare function applyChannelCreation(state: State, channelDef: ChannelDefinition, blockchainId: bigint, tokenAddress: Address, nodeAddress: Address): string;
+export declare function applyReceiverTransitions(state: State, ...transitions: Transition[]): void;
+export declare function applyAcknowledgementTransition(state: State): Transition;
+export declare function applyHomeDepositTransition(state: State, amount: Decimal): Transition;
+export declare function applyHomeWithdrawalTransition(state: State, amount: Decimal): Transition;
+export declare function applyTransferSendTransition(state: State, recipient: string, amount: Decimal): Transition;
+export declare function applyTransferReceiveTransition(state: State, sender: string, amount: Decimal, txId: string): Transition;
+export declare function applyCommitTransition(state: State, accountId: string, amount: Decimal): Transition;
+export declare function applyReleaseTransition(state: State, accountId: string, amount: Decimal): Transition;
+export declare function applyMutualLockTransition(state: State, blockchainId: bigint, tokenAddress: Address, amount: Decimal): Transition;
+export declare function applyEscrowDepositTransition(state: State, amount: Decimal): Transition;
+export declare function applyEscrowLockTransition(state: State, blockchainId: bigint, tokenAddress: Address, amount: Decimal): Transition;
+export declare function applyEscrowWithdrawTransition(state: State, amount: Decimal): Transition;
+export declare function applyMigrateTransition(state: State, amount: Decimal): Transition;
+export declare function applyFinalizeTransition(state: State): Transition;

package/dist/core/state.js

@@ -0,0 +1,267 @@
+import Decimal from 'decimal.js';
+import { TransitionType, newTransition, } from './types';
+import { getHomeChannelId, getEscrowChannelId, getStateId, getSenderTransactionId, getReceiverTransactionId } from './utils';
+export function getLastTransition(state) {
+    if (state.transition.type === TransitionType.Void) {
+        return null;
+    }
+    if (state.transition.type === TransitionType.TransferReceive ||
+        state.transition.type === TransitionType.Release) {
+        return null;
+    }
+    return state.transition;
+}
+export function isFinal(state) {
+    return state.transition.type === TransitionType.Finalize;
+}
+export function nextState(state) {
+    let newState;
+    const voidTransition = { type: TransitionType.Void, txId: '', amount: new Decimal(0) };
+    if (isFinal(state)) {
+        newState = {
+            id: '',
+            transition: voidTransition,
+            asset: state.asset,
+            userWallet: state.userWallet,
+            epoch: state.epoch + 1n,
+            version: 0n,
+            homeChannelId: undefined,
+            escrowChannelId: undefined,
+            homeLedger: {
+                tokenAddress: '0x0',
+                blockchainId: 0n,
+                userBalance: new Decimal(0),
+                userNetFlow: new Decimal(0),
+                nodeBalance: new Decimal(0),
+                nodeNetFlow: new Decimal(0),
+            },
+            escrowLedger: undefined,
+        };
+    }
+    else {
+        newState = {
+            id: '',
+            transition: voidTransition,
+            asset: state.asset,
+            userWallet: state.userWallet,
+            epoch: state.epoch,
+            version: state.version + 1n,
+            homeChannelId: state.homeChannelId,
+            escrowChannelId: state.escrowChannelId,
+            homeLedger: { ...state.homeLedger },
+            escrowLedger: undefined,
+        };
+    }
+    if (state.escrowLedger) {
+        newState.escrowLedger = { ...state.escrowLedger };
+        if (!state.userSig) {
+            newState.transition = { ...state.transition };
+        }
+        else {
+            if (state.transition.type === TransitionType.EscrowDeposit ||
+                state.transition.type === TransitionType.EscrowWithdraw) {
+                newState.escrowChannelId = undefined;
+                newState.escrowLedger = undefined;
+            }
+        }
+    }
+    newState.id = getStateId(newState.userWallet, newState.asset, newState.epoch, newState.version);
+    return newState;
+}
+export function applyChannelCreation(state, channelDef, blockchainId, tokenAddress, nodeAddress) {
+    state.homeLedger.tokenAddress = tokenAddress;
+    state.homeLedger.blockchainId = blockchainId;
+    const homeChannelId = getHomeChannelId(nodeAddress, state.userWallet, state.asset, channelDef.nonce, channelDef.challenge, channelDef.approvedSigValidators);
+    state.homeChannelId = homeChannelId;
+    return homeChannelId;
+}
+export function applyReceiverTransitions(state, ...transitions) {
+    for (const transition of transitions) {
+        switch (transition.type) {
+            case TransitionType.TransferReceive:
+                if (!transition.accountId) {
+                    throw new Error('missing account ID for transfer receive transition');
+                }
+                applyTransferReceiveTransition(state, transition.accountId, transition.amount, transition.txId);
+                break;
+            case TransitionType.Release:
+                if (!transition.accountId) {
+                    throw new Error('missing account ID for release transition');
+                }
+                applyReleaseTransition(state, transition.accountId, transition.amount);
+                break;
+            default:
+                throw new Error(`transition '${transition.type}' cannot be applied by receiver`);
+        }
+    }
+}
+export function applyAcknowledgementTransition(state) {
+    if (state.transition.type !== TransitionType.Void) {
+        throw new Error(`state already has a transition: ${state.transition.type}`);
+    }
+    const zeroHash = '0x0000000000000000000000000000000000000000000000000000000000000000';
+    const newTransitionObj = newTransition(TransitionType.Acknowledgement, zeroHash, zeroHash, new Decimal(0));
+    state.transition = newTransitionObj;
+    return newTransitionObj;
+}
+export function applyHomeDepositTransition(state, amount) {
+    if (!state.homeChannelId) {
+        throw new Error('missing home channel ID');
+    }
+    const accountId = state.homeChannelId;
+    const txId = getSenderTransactionId(accountId, state.id);
+    const newTransitionObj = newTransition(TransitionType.HomeDeposit, txId, accountId, amount);
+    state.transition = newTransitionObj;
+    state.homeLedger.userNetFlow = state.homeLedger.userNetFlow.add(newTransitionObj.amount);
+    state.homeLedger.userBalance = state.homeLedger.userBalance.add(newTransitionObj.amount);
+    return newTransitionObj;
+}
+export function applyHomeWithdrawalTransition(state, amount) {
+    if (!state.homeChannelId) {
+        throw new Error('missing home channel ID');
+    }
+    const accountId = state.homeChannelId;
+    const txId = getSenderTransactionId(accountId, state.id);
+    const newTransitionObj = newTransition(TransitionType.HomeWithdrawal, txId, accountId, amount);
+    state.transition = newTransitionObj;
+    state.homeLedger.userNetFlow = state.homeLedger.userNetFlow.sub(newTransitionObj.amount);
+    state.homeLedger.userBalance = state.homeLedger.userBalance.sub(newTransitionObj.amount);
+    return newTransitionObj;
+}
+export function applyTransferSendTransition(state, recipient, amount) {
+    const accountId = recipient;
+    const txId = getSenderTransactionId(accountId, state.id);
+    const newTransitionObj = newTransition(TransitionType.TransferSend, txId, accountId, amount);
+    state.transition = newTransitionObj;
+    state.homeLedger.userBalance = state.homeLedger.userBalance.sub(newTransitionObj.amount);
+    state.homeLedger.nodeNetFlow = state.homeLedger.nodeNetFlow.sub(newTransitionObj.amount);
+    return newTransitionObj;
+}
+export function applyTransferReceiveTransition(state, sender, amount, txId) {
+    const accountId = sender;
+    const newTransitionObj = newTransition(TransitionType.TransferReceive, txId, accountId, amount);
+    state.transition = newTransitionObj;
+    state.homeLedger.userBalance = state.homeLedger.userBalance.add(newTransitionObj.amount);
+    state.homeLedger.nodeNetFlow = state.homeLedger.nodeNetFlow.add(newTransitionObj.amount);
+    return newTransitionObj;
+}
+export function applyCommitTransition(state, accountId, amount) {
+    const txId = getSenderTransactionId(accountId, state.id);
+    const newTransitionObj = newTransition(TransitionType.Commit, txId, accountId, amount);
+    state.transition = newTransitionObj;
+    state.homeLedger.userBalance = state.homeLedger.userBalance.sub(newTransitionObj.amount);
+    state.homeLedger.nodeNetFlow = state.homeLedger.nodeNetFlow.sub(newTransitionObj.amount);
+    return newTransitionObj;
+}
+export function applyReleaseTransition(state, accountId, amount) {
+    const txId = getReceiverTransactionId(accountId, state.id);
+    const newTransitionObj = newTransition(TransitionType.Release, txId, accountId, amount);
+    state.transition = newTransitionObj;
+    state.homeLedger.userBalance = state.homeLedger.userBalance.add(newTransitionObj.amount);
+    state.homeLedger.nodeNetFlow = state.homeLedger.nodeNetFlow.add(newTransitionObj.amount);
+    return newTransitionObj;
+}
+export function applyMutualLockTransition(state, blockchainId, tokenAddress, amount) {
+    if (!state.homeChannelId) {
+        throw new Error('missing home channel ID');
+    }
+    if (blockchainId === 0n) {
+        throw new Error('invalid blockchain ID');
+    }
+    if (!tokenAddress || tokenAddress === '0x0') {
+        throw new Error('invalid token address');
+    }
+    const escrowChannelId = getEscrowChannelId(state.homeChannelId, state.version);
+    state.escrowChannelId = escrowChannelId;
+    const accountId = escrowChannelId;
+    const txId = getSenderTransactionId(accountId, state.id);
+    const newTransitionObj = newTransition(TransitionType.MutualLock, txId, accountId, amount);
+    state.transition = newTransitionObj;
+    state.homeLedger.nodeBalance = state.homeLedger.nodeBalance.add(newTransitionObj.amount);
+    state.homeLedger.nodeNetFlow = state.homeLedger.nodeNetFlow.add(newTransitionObj.amount);
+    state.escrowLedger = {
+        blockchainId,
+        tokenAddress,
+        userBalance: new Decimal(0).add(newTransitionObj.amount),
+        userNetFlow: new Decimal(0).add(newTransitionObj.amount),
+        nodeBalance: new Decimal(0),
+        nodeNetFlow: new Decimal(0),
+    };
+    return newTransitionObj;
+}
+export function applyEscrowDepositTransition(state, amount) {
+    if (!state.escrowChannelId) {
+        throw new Error('internal error: escrow channel ID is nil');
+    }
+    if (!state.escrowLedger) {
+        throw new Error('escrow ledger is nil');
+    }
+    const accountId = state.escrowChannelId;
+    const txId = getSenderTransactionId(accountId, state.id);
+    const newTransitionObj = newTransition(TransitionType.EscrowDeposit, txId, accountId, amount);
+    state.transition = newTransitionObj;
+    state.homeLedger.userBalance = state.homeLedger.userBalance.add(newTransitionObj.amount);
+    state.homeLedger.nodeNetFlow = state.homeLedger.nodeNetFlow.add(newTransitionObj.amount);
+    state.escrowLedger.userBalance = state.escrowLedger.userBalance.sub(newTransitionObj.amount);
+    state.escrowLedger.nodeNetFlow = state.escrowLedger.nodeNetFlow.sub(newTransitionObj.amount);
+    return newTransitionObj;
+}
+export function applyEscrowLockTransition(state, blockchainId, tokenAddress, amount) {
+    if (!state.homeChannelId) {
+        throw new Error('missing home channel ID');
+    }
+    if (blockchainId === 0n) {
+        throw new Error('invalid blockchain ID');
+    }
+    if (!tokenAddress || tokenAddress === '0x0') {
+        throw new Error('invalid token address');
+    }
+    const escrowChannelId = getEscrowChannelId(state.homeChannelId, state.version);
+    state.escrowChannelId = escrowChannelId;
+    const accountId = escrowChannelId;
+    const txId = getSenderTransactionId(accountId, state.id);
+    const newTransitionObj = newTransition(TransitionType.EscrowLock, txId, accountId, amount);
+    state.transition = newTransitionObj;
+    state.escrowLedger = {
+        blockchainId,
+        tokenAddress,
+        userBalance: new Decimal(0),
+        userNetFlow: new Decimal(0),
+        nodeBalance: new Decimal(0).add(newTransitionObj.amount),
+        nodeNetFlow: new Decimal(0).add(newTransitionObj.amount),
+    };
+    return newTransitionObj;
+}
+export function applyEscrowWithdrawTransition(state, amount) {
+    if (!state.escrowChannelId) {
+        throw new Error('internal error: escrow channel ID is nil');
+    }
+    if (!state.escrowLedger) {
+        throw new Error('escrow ledger is nil');
+    }
+    const accountId = state.escrowChannelId;
+    const txId = getSenderTransactionId(accountId, state.id);
+    const newTransitionObj = newTransition(TransitionType.EscrowWithdraw, txId, accountId, amount);
+    state.transition = newTransitionObj;
+    state.homeLedger.userBalance = state.homeLedger.userBalance.sub(newTransitionObj.amount);
+    state.homeLedger.nodeNetFlow = state.homeLedger.nodeNetFlow.sub(newTransitionObj.amount);
+    state.escrowLedger.userNetFlow = state.escrowLedger.userNetFlow.sub(newTransitionObj.amount);
+    state.escrowLedger.nodeBalance = state.escrowLedger.nodeBalance.sub(newTransitionObj.amount);
+    return newTransitionObj;
+}
+export function applyMigrateTransition(state, amount) {
+    throw new Error('migrate transition not implemented yet');
+}
+export function applyFinalizeTransition(state) {
+    if (!state.homeChannelId) {
+        throw new Error('missing home channel ID');
+    }
+    const accountId = state.homeChannelId;
+    const amount = state.homeLedger.userBalance;
+    const txId = getSenderTransactionId(accountId, state.id);
+    const newTransitionObj = newTransition(TransitionType.Finalize, txId, accountId, amount);
+    state.transition = newTransitionObj;
+    state.homeLedger.userNetFlow = state.homeLedger.userNetFlow.sub(state.homeLedger.userBalance);
+    state.homeLedger.userBalance = new Decimal(0);
+    return newTransitionObj;
+}

package/dist/core/state_packer.d.ts

@@ -0,0 +1,13 @@
+import { State } from './types';
+import { AssetStore, StatePacker } from './interface';
+export declare class StatePackerV1 implements StatePacker {
+    private assetStore;
+    constructor(assetStore: AssetStore);
+    private packSigningData;
+    private packWithChannelId;
+    packState(state: State): Promise<`0x${string}`>;
+    packChallengeState(state: State): Promise<`0x${string}`>;
+}
+export declare function newStatePackerV1(assetStore: AssetStore): StatePackerV1;
+export declare function packState(state: State, assetStore: AssetStore): Promise<`0x${string}`>;
+export declare function packChallengeState(state: State, assetStore: AssetStore): Promise<`0x${string}`>;

package/dist/core/state_packer.js

@@ -0,0 +1,98 @@
+import { encodeAbiParameters, concat, toHex } from 'viem';
+import { getStateTransitionHash, transitionToIntent, decimalToBigInt } from './utils';
+export class StatePackerV1 {
+    constructor(assetStore) {
+        this.assetStore = assetStore;
+    }
+    async packSigningData(state) {
+        if (!state.homeChannelId) {
+            throw new Error('state.homeChannelId is required for packing');
+        }
+        const channelId = state.homeChannelId;
+        const metadata = getStateTransitionHash(state.transition);
+        const homeDecimals = await this.assetStore.getTokenDecimals(state.homeLedger.blockchainId, state.homeLedger.tokenAddress);
+        const homeLedger = {
+            chainId: state.homeLedger.blockchainId,
+            token: state.homeLedger.tokenAddress,
+            decimals: homeDecimals,
+            userAllocation: decimalToBigInt(state.homeLedger.userBalance, homeDecimals),
+            userNetFlow: decimalToBigInt(state.homeLedger.userNetFlow, homeDecimals),
+            nodeAllocation: decimalToBigInt(state.homeLedger.nodeBalance, homeDecimals),
+            nodeNetFlow: decimalToBigInt(state.homeLedger.nodeNetFlow, homeDecimals),
+        };
+        let nonHomeLedger;
+        if (state.escrowLedger) {
+            const escrowDecimals = await this.assetStore.getTokenDecimals(state.escrowLedger.blockchainId, state.escrowLedger.tokenAddress);
+            nonHomeLedger = {
+                chainId: state.escrowLedger.blockchainId,
+                token: state.escrowLedger.tokenAddress,
+                decimals: escrowDecimals,
+                userAllocation: decimalToBigInt(state.escrowLedger.userBalance, escrowDecimals),
+                userNetFlow: decimalToBigInt(state.escrowLedger.userNetFlow, escrowDecimals),
+                nodeAllocation: decimalToBigInt(state.escrowLedger.nodeBalance, escrowDecimals),
+                nodeNetFlow: decimalToBigInt(state.escrowLedger.nodeNetFlow, escrowDecimals),
+            };
+        }
+        else {
+            nonHomeLedger = {
+                chainId: 0n,
+                token: '0x0000000000000000000000000000000000000000',
+                decimals: 0,
+                userAllocation: 0n,
+                userNetFlow: 0n,
+                nodeAllocation: 0n,
+                nodeNetFlow: 0n,
+            };
+        }
+        const intent = transitionToIntent(state.transition);
+        const ledgerComponents = [
+            { name: 'chainId', type: 'uint64' },
+            { name: 'token', type: 'address' },
+            { name: 'decimals', type: 'uint8' },
+            { name: 'userAllocation', type: 'uint256' },
+            { name: 'userNetFlow', type: 'int256' },
+            { name: 'nodeAllocation', type: 'uint256' },
+            { name: 'nodeNetFlow', type: 'int256' },
+        ];
+        const signingData = encodeAbiParameters([
+            { type: 'uint64' },
+            { type: 'uint8' },
+            { type: 'bytes32' },
+            { type: 'tuple', components: ledgerComponents },
+            { type: 'tuple', components: ledgerComponents },
+        ], [
+            state.version,
+            intent,
+            metadata,
+            homeLedger,
+            nonHomeLedger,
+        ]);
+        return { channelId, signingData };
+    }
+    packWithChannelId(channelId, signingData) {
+        return encodeAbiParameters([
+            { type: 'bytes32' },
+            { type: 'bytes' },
+        ], [channelId, signingData]);
+    }
+    async packState(state) {
+        const { channelId, signingData } = await this.packSigningData(state);
+        return this.packWithChannelId(channelId, signingData);
+    }
+    async packChallengeState(state) {
+        const { channelId, signingData } = await this.packSigningData(state);
+        const challengeSigningData = concat([signingData, toHex('challenge')]);
+        return this.packWithChannelId(channelId, challengeSigningData);
+    }
+}
+export function newStatePackerV1(assetStore) {
+    return new StatePackerV1(assetStore);
+}
+export async function packState(state, assetStore) {
+    const packer = newStatePackerV1(assetStore);
+    return packer.packState(state);
+}
+export async function packChallengeState(state, assetStore) {
+    const packer = newStatePackerV1(assetStore);
+    return packer.packChallengeState(state);
+}