@yellow-org/sdk 1.0.0-alpha.0

package/dist/core/types.d.ts

@@ -0,0 +1,203 @@
+import { Address, Hex } from 'viem';
+import Decimal from 'decimal.js';
+export declare enum ChannelType {
+    Home = 1,
+    Escrow = 2
+}
+export declare enum ChannelParticipant {
+    User = 0,
+    Node = 1
+}
+export declare enum ChannelSignerType {
+    Default = 0,
+    SessionKey = 1
+}
+export declare enum ChannelStatus {
+    Void = 0,
+    Open = 1,
+    Challenged = 2,
+    Closed = 3
+}
+export declare enum TransitionType {
+    Void = 0,
+    Acknowledgement = 1,
+    HomeDeposit = 10,
+    HomeWithdrawal = 11,
+    EscrowDeposit = 20,
+    EscrowWithdraw = 21,
+    TransferSend = 30,
+    TransferReceive = 31,
+    Commit = 40,
+    Release = 41,
+    Migrate = 100,
+    EscrowLock = 110,
+    MutualLock = 120,
+    Finalize = 200
+}
+export declare enum TransactionType {
+    HomeDeposit = 10,
+    HomeWithdrawal = 11,
+    EscrowDeposit = 20,
+    EscrowWithdraw = 21,
+    Transfer = 30,
+    Commit = 40,
+    Release = 41,
+    Rebalance = 42,
+    Migrate = 100,
+    EscrowLock = 110,
+    MutualLock = 120,
+    Finalize = 200
+}
+export declare const INTENT_OPERATE = 0;
+export declare const INTENT_CLOSE = 1;
+export declare const INTENT_DEPOSIT = 2;
+export declare const INTENT_WITHDRAW = 3;
+export declare const INTENT_INITIATE_ESCROW_DEPOSIT = 4;
+export declare const INTENT_FINALIZE_ESCROW_DEPOSIT = 5;
+export declare const INTENT_INITIATE_ESCROW_WITHDRAWAL = 6;
+export declare const INTENT_FINALIZE_ESCROW_WITHDRAWAL = 7;
+export declare const INTENT_INITIATE_MIGRATION = 8;
+export declare const INTENT_FINALIZE_MIGRATION = 9;
+export interface ChannelDefinition {
+    nonce: bigint;
+    challenge: number;
+    approvedSigValidators: string;
+}
+export interface Channel {
+    channelId: string;
+    userWallet: Address;
+    asset: string;
+    type: ChannelType;
+    blockchainId: bigint;
+    tokenAddress: Address;
+    challengeDuration: number;
+    challengeExpiresAt?: Date;
+    nonce: bigint;
+    approvedSigValidators: string;
+    status: ChannelStatus;
+    stateVersion: bigint;
+}
+export interface Ledger {
+    tokenAddress: Address;
+    blockchainId: bigint;
+    userBalance: Decimal;
+    userNetFlow: Decimal;
+    nodeBalance: Decimal;
+    nodeNetFlow: Decimal;
+}
+export interface Transition {
+    type: TransitionType;
+    txId: string;
+    accountId?: string;
+    amount: Decimal;
+}
+export interface State {
+    id: string;
+    transition: Transition;
+    asset: string;
+    userWallet: Address;
+    epoch: bigint;
+    version: bigint;
+    homeChannelId?: string;
+    escrowChannelId?: string;
+    homeLedger: Ledger;
+    escrowLedger?: Ledger;
+    userSig?: Hex;
+    nodeSig?: Hex;
+}
+export interface Transaction {
+    id: string;
+    asset: string;
+    txType: TransactionType;
+    fromAccount: Address;
+    toAccount: Address;
+    senderNewStateId?: string;
+    receiverNewStateId?: string;
+    amount: Decimal;
+    createdAt: Date;
+}
+export interface Blockchain {
+    name: string;
+    id: bigint;
+    channelHubAddress: Address;
+    blockStep: bigint;
+}
+export interface Token {
+    name: string;
+    symbol: string;
+    address: Address;
+    blockchainId: bigint;
+    decimals: number;
+}
+export interface Asset {
+    name: string;
+    decimals: number;
+    symbol: string;
+    suggestedBlockchainId: bigint;
+    tokens: Token[];
+}
+export interface AssetAllowance {
+    asset: string;
+    allowance: Decimal;
+    used: Decimal;
+}
+export interface SessionKey {
+    id: bigint;
+    sessionKey: string;
+    application: string;
+    allowances: AssetAllowance[];
+    scope?: string;
+    expiresAt: string;
+    createdAt: string;
+}
+export interface BalanceEntry {
+    asset: string;
+    balance: Decimal;
+}
+export interface PaginationParams {
+    offset?: number;
+    limit?: number;
+}
+export interface PaginationMetadata {
+    page: number;
+    perPage: number;
+    totalCount: number;
+    pageCount: number;
+}
+export interface NodeConfig {
+    nodeAddress: Address;
+    nodeVersion: string;
+    supportedSigValidators: number[];
+    blockchains: Blockchain[];
+}
+export interface HomeChannelDataResponse {
+    definition: ChannelDefinition;
+    node: Address;
+    lastState: State;
+    challengeExpiry: bigint;
+}
+export interface EscrowDepositDataResponse {
+    escrowChannelId: string;
+    node: Address;
+    lastState: State;
+    unlockExpiry: bigint;
+    challengeExpiry: bigint;
+}
+export interface EscrowWithdrawalDataResponse {
+    escrowChannelId: string;
+    node: Address;
+    lastState: State;
+}
+export declare function newChannel(channelId: string, userWallet: Address, asset: string, type: ChannelType, blockchainId: bigint, tokenAddress: Address, nonce: bigint, challenge: number, approvedSigValidators?: string): Channel;
+export declare function newVoidState(asset: string, userWallet: Address): State;
+export declare function newTransition(type: TransitionType, txId: string, accountId: string, amount: Decimal): Transition;
+export declare function newTransaction(id: string, asset: string, txType: TransactionType, fromAccount: Address, toAccount: Address, amount: Decimal): Transaction;
+export declare function transitionToString(type: TransitionType): string;
+export declare function transitionRequiresOpenChannel(type: TransitionType): boolean;
+export declare function transitionsEqual(a: Transition, b: Transition): string | null;
+export declare function ledgerEqual(a: Ledger, b: Ledger): string | null;
+export declare function validateLedger(ledger: Ledger): void;
+export declare function getOffsetAndLimit(params: PaginationParams | undefined, defaultLimit: number, maxLimit: number): {
+    offset: number;
+    limit: number;
+};

package/dist/core/types.js

@@ -0,0 +1,220 @@
+import Decimal from 'decimal.js';
+export var ChannelType;
+(function (ChannelType) {
+    ChannelType[ChannelType["Home"] = 1] = "Home";
+    ChannelType[ChannelType["Escrow"] = 2] = "Escrow";
+})(ChannelType || (ChannelType = {}));
+export var ChannelParticipant;
+(function (ChannelParticipant) {
+    ChannelParticipant[ChannelParticipant["User"] = 0] = "User";
+    ChannelParticipant[ChannelParticipant["Node"] = 1] = "Node";
+})(ChannelParticipant || (ChannelParticipant = {}));
+export var ChannelSignerType;
+(function (ChannelSignerType) {
+    ChannelSignerType[ChannelSignerType["Default"] = 0] = "Default";
+    ChannelSignerType[ChannelSignerType["SessionKey"] = 1] = "SessionKey";
+})(ChannelSignerType || (ChannelSignerType = {}));
+export var ChannelStatus;
+(function (ChannelStatus) {
+    ChannelStatus[ChannelStatus["Void"] = 0] = "Void";
+    ChannelStatus[ChannelStatus["Open"] = 1] = "Open";
+    ChannelStatus[ChannelStatus["Challenged"] = 2] = "Challenged";
+    ChannelStatus[ChannelStatus["Closed"] = 3] = "Closed";
+})(ChannelStatus || (ChannelStatus = {}));
+export var TransitionType;
+(function (TransitionType) {
+    TransitionType[TransitionType["Void"] = 0] = "Void";
+    TransitionType[TransitionType["Acknowledgement"] = 1] = "Acknowledgement";
+    TransitionType[TransitionType["HomeDeposit"] = 10] = "HomeDeposit";
+    TransitionType[TransitionType["HomeWithdrawal"] = 11] = "HomeWithdrawal";
+    TransitionType[TransitionType["EscrowDeposit"] = 20] = "EscrowDeposit";
+    TransitionType[TransitionType["EscrowWithdraw"] = 21] = "EscrowWithdraw";
+    TransitionType[TransitionType["TransferSend"] = 30] = "TransferSend";
+    TransitionType[TransitionType["TransferReceive"] = 31] = "TransferReceive";
+    TransitionType[TransitionType["Commit"] = 40] = "Commit";
+    TransitionType[TransitionType["Release"] = 41] = "Release";
+    TransitionType[TransitionType["Migrate"] = 100] = "Migrate";
+    TransitionType[TransitionType["EscrowLock"] = 110] = "EscrowLock";
+    TransitionType[TransitionType["MutualLock"] = 120] = "MutualLock";
+    TransitionType[TransitionType["Finalize"] = 200] = "Finalize";
+})(TransitionType || (TransitionType = {}));
+export var TransactionType;
+(function (TransactionType) {
+    TransactionType[TransactionType["HomeDeposit"] = 10] = "HomeDeposit";
+    TransactionType[TransactionType["HomeWithdrawal"] = 11] = "HomeWithdrawal";
+    TransactionType[TransactionType["EscrowDeposit"] = 20] = "EscrowDeposit";
+    TransactionType[TransactionType["EscrowWithdraw"] = 21] = "EscrowWithdraw";
+    TransactionType[TransactionType["Transfer"] = 30] = "Transfer";
+    TransactionType[TransactionType["Commit"] = 40] = "Commit";
+    TransactionType[TransactionType["Release"] = 41] = "Release";
+    TransactionType[TransactionType["Rebalance"] = 42] = "Rebalance";
+    TransactionType[TransactionType["Migrate"] = 100] = "Migrate";
+    TransactionType[TransactionType["EscrowLock"] = 110] = "EscrowLock";
+    TransactionType[TransactionType["MutualLock"] = 120] = "MutualLock";
+    TransactionType[TransactionType["Finalize"] = 200] = "Finalize";
+})(TransactionType || (TransactionType = {}));
+export const INTENT_OPERATE = 0;
+export const INTENT_CLOSE = 1;
+export const INTENT_DEPOSIT = 2;
+export const INTENT_WITHDRAW = 3;
+export const INTENT_INITIATE_ESCROW_DEPOSIT = 4;
+export const INTENT_FINALIZE_ESCROW_DEPOSIT = 5;
+export const INTENT_INITIATE_ESCROW_WITHDRAWAL = 6;
+export const INTENT_FINALIZE_ESCROW_WITHDRAWAL = 7;
+export const INTENT_INITIATE_MIGRATION = 8;
+export const INTENT_FINALIZE_MIGRATION = 9;
+export function newChannel(channelId, userWallet, asset, type, blockchainId, tokenAddress, nonce, challenge, approvedSigValidators = '0x00') {
+    return {
+        channelId,
+        userWallet,
+        asset,
+        type,
+        blockchainId,
+        tokenAddress,
+        nonce,
+        challengeDuration: challenge,
+        approvedSigValidators,
+        status: ChannelStatus.Void,
+        stateVersion: 0n,
+    };
+}
+export function newVoidState(asset, userWallet) {
+    return {
+        id: '',
+        transition: { type: TransitionType.Void, txId: '', amount: new Decimal(0) },
+        asset,
+        userWallet,
+        epoch: 0n,
+        version: 0n,
+        homeLedger: {
+            tokenAddress: '0x0',
+            blockchainId: 0n,
+            userBalance: new Decimal(0),
+            userNetFlow: new Decimal(0),
+            nodeBalance: new Decimal(0),
+            nodeNetFlow: new Decimal(0),
+        },
+    };
+}
+export function newTransition(type, txId, accountId, amount) {
+    return {
+        type,
+        txId,
+        accountId,
+        amount,
+    };
+}
+export function newTransaction(id, asset, txType, fromAccount, toAccount, amount) {
+    return {
+        id,
+        asset,
+        txType,
+        fromAccount,
+        toAccount,
+        amount,
+        createdAt: new Date(),
+    };
+}
+export function transitionToString(type) {
+    switch (type) {
+        case TransitionType.Void:
+            return 'Void';
+        case TransitionType.Acknowledgement:
+            return 'Acknowledgement';
+        case TransitionType.HomeDeposit:
+            return 'HomeDeposit';
+        case TransitionType.HomeWithdrawal:
+            return 'HomeWithdrawal';
+        case TransitionType.EscrowDeposit:
+            return 'EscrowDeposit';
+        case TransitionType.EscrowWithdraw:
+            return 'EscrowWithdraw';
+        case TransitionType.TransferSend:
+            return 'TransferSend';
+        case TransitionType.TransferReceive:
+            return 'TransferReceive';
+        case TransitionType.Commit:
+            return 'Commit';
+        case TransitionType.Release:
+            return 'Release';
+        case TransitionType.Migrate:
+            return 'Migrate';
+        case TransitionType.EscrowLock:
+            return 'EscrowLock';
+        case TransitionType.MutualLock:
+            return 'MutualLock';
+        case TransitionType.Finalize:
+            return 'Finalize';
+        default:
+            return 'Unknown';
+    }
+}
+export function transitionRequiresOpenChannel(type) {
+    return type !== TransitionType.TransferReceive && type !== TransitionType.Release;
+}
+export function transitionsEqual(a, b) {
+    if (a.type !== b.type) {
+        return `type mismatch: expected=${a.type}, proposed=${b.type}`;
+    }
+    if (a.txId !== b.txId) {
+        return `tx ID mismatch: expected=${a.txId}, proposed=${b.txId}`;
+    }
+    if (a.accountId !== b.accountId) {
+        return `account ID mismatch: expected=${a.accountId}, proposed=${b.accountId}`;
+    }
+    if (!a.amount.equals(b.amount)) {
+        return `amount mismatch: expected=${a.amount.toString()}, proposed=${b.amount.toString()}`;
+    }
+    return null;
+}
+export function ledgerEqual(a, b) {
+    if (a.tokenAddress.toLowerCase() !== b.tokenAddress.toLowerCase()) {
+        return `token address mismatch: expected=${a.tokenAddress}, proposed=${b.tokenAddress}`;
+    }
+    if (a.blockchainId !== b.blockchainId) {
+        return `blockchain ID mismatch: expected=${a.blockchainId}, proposed=${b.blockchainId}`;
+    }
+    if (!a.userBalance.equals(b.userBalance)) {
+        return `user balance mismatch: expected=${a.userBalance.toString()}, proposed=${b.userBalance.toString()}`;
+    }
+    if (!a.userNetFlow.equals(b.userNetFlow)) {
+        return `user net flow mismatch: expected=${a.userNetFlow.toString()}, proposed=${b.userNetFlow.toString()}`;
+    }
+    if (!a.nodeBalance.equals(b.nodeBalance)) {
+        return `node balance mismatch: expected=${a.nodeBalance.toString()}, proposed=${b.nodeBalance.toString()}`;
+    }
+    if (!a.nodeNetFlow.equals(b.nodeNetFlow)) {
+        return `node net flow mismatch: expected=${a.nodeNetFlow.toString()}, proposed=${b.nodeNetFlow.toString()}`;
+    }
+    return null;
+}
+export function validateLedger(ledger) {
+    if (!ledger.tokenAddress || ledger.tokenAddress === '0x0') {
+        throw new Error('invalid token address');
+    }
+    if (ledger.blockchainId === 0n) {
+        throw new Error('invalid blockchain ID');
+    }
+    if (ledger.userBalance.isNegative()) {
+        throw new Error('user balance cannot be negative');
+    }
+    if (ledger.nodeBalance.isNegative()) {
+        throw new Error('node balance cannot be negative');
+    }
+    const sumBalances = ledger.userBalance.add(ledger.nodeBalance);
+    const sumNetFlows = ledger.userNetFlow.add(ledger.nodeNetFlow);
+    if (!sumBalances.equals(sumNetFlows)) {
+        throw new Error(`ledger balances do not match net flows: balances=${sumBalances.toString()}, net_flows=${sumNetFlows.toString()}`);
+    }
+}
+export function getOffsetAndLimit(params, defaultLimit, maxLimit) {
+    if (!params) {
+        return { offset: 0, limit: defaultLimit };
+    }
+    const offset = params.offset ?? 0;
+    let limit = params.limit ?? defaultLimit;
+    if (limit > maxLimit) {
+        limit = maxLimit;
+    }
+    return { offset, limit };
+}

package/dist/core/utils.d.ts

@@ -0,0 +1,16 @@
+import { Address } from 'viem';
+import Decimal from 'decimal.js';
+import { Transition } from './types';
+export declare const CHANNEL_HUB_VERSION = 1;
+export declare function transitionToIntent(transition: Transition): number;
+export declare function validateDecimalPrecision(amount: Decimal, maxDecimals: number): void;
+export declare function decimalToBigInt(amount: Decimal, decimals: number): bigint;
+export declare function getHomeChannelId(node: Address, user: Address, asset: string, nonce: bigint, challengeDuration: number, approvedSigValidators?: string): string;
+export declare function getEscrowChannelId(homeChannelId: string, stateVersion: bigint): string;
+export declare function getStateId(userWallet: Address, asset: string, epoch: bigint, version: bigint): string;
+export declare function getStateTransitionHash(transition: Transition): string;
+export declare function getSenderTransactionId(toAccount: string, senderNewStateId: string): string;
+export declare function getReceiverTransactionId(fromAccount: string, receiverNewStateId: string): string;
+export declare function generateChannelMetadata(asset: string): `0x${string}`;
+export declare function getChannelSessionKeyAuthMetadataHashV1(version: bigint, assets: string[], expiresAt: bigint): `0x${string}`;
+export declare function packChannelKeyStateV1(sessionKey: Address, metadataHash: `0x${string}`): `0x${string}`;

package/dist/core/utils.js

@@ -0,0 +1,181 @@
+import { encodeAbiParameters, keccak256, toHex, pad, slice } from 'viem';
+import Decimal from 'decimal.js';
+import { TransitionType, INTENT_OPERATE, INTENT_CLOSE, INTENT_DEPOSIT, INTENT_WITHDRAW, INTENT_INITIATE_ESCROW_DEPOSIT, INTENT_FINALIZE_ESCROW_DEPOSIT, INTENT_INITIATE_ESCROW_WITHDRAWAL, INTENT_FINALIZE_ESCROW_WITHDRAWAL, INTENT_INITIATE_MIGRATION, } from './types';
+Decimal.set({ precision: 50 });
+export const CHANNEL_HUB_VERSION = 1;
+export function transitionToIntent(transition) {
+    switch (transition.type) {
+        case TransitionType.Void:
+        case TransitionType.TransferSend:
+        case TransitionType.TransferReceive:
+        case TransitionType.Commit:
+        case TransitionType.Release:
+            return INTENT_OPERATE;
+        case TransitionType.Finalize:
+            return INTENT_CLOSE;
+        case TransitionType.HomeDeposit:
+            return INTENT_DEPOSIT;
+        case TransitionType.HomeWithdrawal:
+            return INTENT_WITHDRAW;
+        case TransitionType.MutualLock:
+            return INTENT_INITIATE_ESCROW_DEPOSIT;
+        case TransitionType.EscrowDeposit:
+            return INTENT_FINALIZE_ESCROW_DEPOSIT;
+        case TransitionType.EscrowLock:
+            return INTENT_INITIATE_ESCROW_WITHDRAWAL;
+        case TransitionType.EscrowWithdraw:
+            return INTENT_FINALIZE_ESCROW_WITHDRAWAL;
+        case TransitionType.Migrate:
+            return INTENT_INITIATE_MIGRATION;
+        default:
+            return INTENT_OPERATE;
+    }
+}
+export function validateDecimalPrecision(amount, maxDecimals) {
+    const exponent = amount.decimalPlaces();
+    if (exponent > maxDecimals) {
+        throw new Error(`amount exceeds maximum decimal precision: max ${maxDecimals} decimals allowed, got ${exponent}`);
+    }
+}
+export function decimalToBigInt(amount, decimals) {
+    const multiplier = new Decimal(10).pow(decimals);
+    const scaled = amount.mul(multiplier);
+    if (!scaled.isInteger()) {
+        throw new Error(`amount ${amount.toString()} exceeds maximum decimal precision: max ${decimals} decimals allowed`);
+    }
+    return BigInt(scaled.toFixed(0));
+}
+export function getHomeChannelId(node, user, asset, nonce, challengeDuration, approvedSigValidators = '0x00') {
+    const metadata = generateChannelMetadata(asset);
+    const validatorsBigInt = BigInt(approvedSigValidators || '0x00');
+    const packed = encodeAbiParameters([
+        {
+            name: 'channelDefinition',
+            type: 'tuple',
+            components: [
+                { name: 'challengeDuration', type: 'uint32' },
+                { name: 'user', type: 'address' },
+                { name: 'node', type: 'address' },
+                { name: 'nonce', type: 'uint64' },
+                { name: 'approvedSignatureValidators', type: 'uint256' },
+                { name: 'metadata', type: 'bytes32' },
+            ],
+        },
+    ], [
+        {
+            challengeDuration: challengeDuration,
+            user: user,
+            node: node,
+            nonce: nonce,
+            approvedSignatureValidators: validatorsBigInt,
+            metadata: metadata,
+        },
+    ]);
+    const baseId = keccak256(packed);
+    const versionHex = CHANNEL_HUB_VERSION.toString(16).padStart(2, '0');
+    return `0x${versionHex}${baseId.slice(4)}`;
+}
+export function getEscrowChannelId(homeChannelId, stateVersion) {
+    const packed = encodeAbiParameters([{ type: 'bytes32' }, { type: 'uint64' }], [homeChannelId, stateVersion]);
+    return keccak256(packed);
+}
+export function getStateId(userWallet, asset, epoch, version) {
+    const packed = encodeAbiParameters([{ type: 'address' }, { type: 'string' }, { type: 'uint256' }, { type: 'uint256' }], [userWallet, asset, epoch, version]);
+    return keccak256(packed);
+}
+export function getStateTransitionHash(transition) {
+    const contractTransition = {
+        type: transition.type,
+        txId: hexToBytes32(transition.txId),
+        accountId: parseAccountIdToBytes32(transition.accountId),
+        amount: transition.amount.toString(),
+    };
+    const packed = encodeAbiParameters([
+        {
+            type: 'tuple',
+            components: [
+                { name: 'type', type: 'uint8' },
+                { name: 'txId', type: 'bytes32' },
+                { name: 'accountId', type: 'bytes32' },
+                { name: 'amount', type: 'string' },
+            ],
+        },
+    ], [contractTransition]);
+    return keccak256(packed);
+}
+export function getSenderTransactionId(toAccount, senderNewStateId) {
+    return getTransactionId(toAccount, senderNewStateId);
+}
+export function getReceiverTransactionId(fromAccount, receiverNewStateId) {
+    return getTransactionId(fromAccount, receiverNewStateId);
+}
+function getTransactionId(account, newStateId) {
+    const packed = encodeAbiParameters([{ type: 'string' }, { type: 'bytes32' }], [account, newStateId]);
+    return keccak256(packed);
+}
+export function generateChannelMetadata(asset) {
+    const assetHash = keccak256(toHex(asset));
+    const first8Bytes = slice(assetHash, 0, 8);
+    const metadata = pad(first8Bytes, { dir: 'right', size: 32 });
+    return metadata;
+}
+function hexToBytes32(hexStr) {
+    let cleaned = hexStr.startsWith('0x') ? hexStr.slice(2) : hexStr;
+    if (cleaned.length % 2 === 1) {
+        cleaned = '0' + cleaned;
+    }
+    const bytes = [];
+    for (let i = 0; i < cleaned.length; i += 2) {
+        const hexPair = cleaned.slice(i, i + 2);
+        if (!/^[0-9a-fA-F]{2}$/.test(hexPair)) {
+            break;
+        }
+        bytes.push(parseInt(hexPair, 16));
+    }
+    const hexResult = bytes.map(b => b.toString(16).padStart(2, '0')).join('');
+    return pad(`0x${hexResult}`, { dir: 'left', size: 32 });
+}
+function parseAccountIdToBytes32(accountId) {
+    if (!accountId || accountId === '') {
+        return '0x0000000000000000000000000000000000000000000000000000000000000000';
+    }
+    let cleaned = accountId.startsWith('0x') ? accountId.slice(2) : accountId;
+    const hexLength = cleaned.length;
+    if (hexLength === 40 || hexLength === 64) {
+        if (/^[0-9a-fA-F]+$/.test(cleaned)) {
+            if (hexLength === 40) {
+                return pad((`0x${cleaned}`), { size: 32 });
+            }
+            else {
+                return `0x${cleaned}`;
+            }
+        }
+    }
+    if (cleaned.length % 2 === 1) {
+        cleaned = '0' + cleaned;
+    }
+    const bytes = [];
+    for (let i = 0; i < cleaned.length; i += 2) {
+        const hexPair = cleaned.slice(i, i + 2);
+        if (!/^[0-9a-fA-F]{2}$/.test(hexPair)) {
+            break;
+        }
+        bytes.push(parseInt(hexPair, 16));
+    }
+    const hexResult = bytes.map(b => b.toString(16).padStart(2, '0')).join('');
+    return pad(`0x${hexResult}`, { dir: 'left', size: 32 });
+}
+export function getChannelSessionKeyAuthMetadataHashV1(version, assets, expiresAt) {
+    const packed = encodeAbiParameters([
+        { type: 'uint64' },
+        { type: 'string[]' },
+        { type: 'uint64' },
+    ], [version, assets, expiresAt]);
+    return keccak256(packed);
+}
+export function packChannelKeyStateV1(sessionKey, metadataHash) {
+    return encodeAbiParameters([
+        { type: 'address' },
+        { type: 'bytes32' },
+    ], [sessionKey, metadataHash]);
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { Client, DEFAULT_CHALLENGE_PERIOD, type StateSigner, type TransactionSigner } from './client';
+export { EthereumMsgSigner, EthereumRawSigner, ChannelDefaultSigner, ChannelSessionKeyStateSigner, createSigners, } from './signers';
+export { type Config, DefaultConfig, type Option, withHandshakeTimeout, withErrorHandler, withBlockchainRPC } from './config';
+export { ClientAssetStore } from './asset_store';
+export * from './utils';
+export * from './core';
+export * from './app';
+export * from './blockchain';
+export * from './rpc';

package/dist/index.js

@@ -0,0 +1,9 @@
+export { Client, DEFAULT_CHALLENGE_PERIOD } from './client';
+export { EthereumMsgSigner, EthereumRawSigner, ChannelDefaultSigner, ChannelSessionKeyStateSigner, createSigners, } from './signers';
+export { DefaultConfig, withHandshakeTimeout, withErrorHandler, withBlockchainRPC } from './config';
+export { ClientAssetStore } from './asset_store';
+export * from './utils';
+export * from './core';
+export * from './app';
+export * from './blockchain';
+export * from './rpc';