@yellow-org/sdk 1.0.1-alpha.0

package/dist/blockchain/evm/erc20_abi.js

@@ -0,0 +1,96 @@
+export const Erc20Abi = [
+    {
+        type: 'function',
+        name: 'name',
+        inputs: [],
+        outputs: [{ name: '', type: 'string' }],
+        stateMutability: 'view',
+    },
+    {
+        type: 'function',
+        name: 'symbol',
+        inputs: [],
+        outputs: [{ name: '', type: 'string' }],
+        stateMutability: 'view',
+    },
+    {
+        type: 'function',
+        name: 'decimals',
+        inputs: [],
+        outputs: [{ name: '', type: 'uint8' }],
+        stateMutability: 'view',
+    },
+    {
+        type: 'function',
+        name: 'totalSupply',
+        inputs: [],
+        outputs: [{ name: '', type: 'uint256' }],
+        stateMutability: 'view',
+    },
+    {
+        type: 'function',
+        name: 'balanceOf',
+        inputs: [{ name: 'account', type: 'address' }],
+        outputs: [{ name: '', type: 'uint256' }],
+        stateMutability: 'view',
+    },
+    {
+        type: 'function',
+        name: 'transfer',
+        inputs: [
+            { name: 'to', type: 'address' },
+            { name: 'amount', type: 'uint256' },
+        ],
+        outputs: [{ name: '', type: 'bool' }],
+        stateMutability: 'nonpayable',
+    },
+    {
+        type: 'function',
+        name: 'allowance',
+        inputs: [
+            { name: 'owner', type: 'address' },
+            { name: 'spender', type: 'address' },
+        ],
+        outputs: [{ name: '', type: 'uint256' }],
+        stateMutability: 'view',
+    },
+    {
+        type: 'function',
+        name: 'approve',
+        inputs: [
+            { name: 'spender', type: 'address' },
+            { name: 'amount', type: 'uint256' },
+        ],
+        outputs: [{ name: '', type: 'bool' }],
+        stateMutability: 'nonpayable',
+    },
+    {
+        type: 'function',
+        name: 'transferFrom',
+        inputs: [
+            { name: 'from', type: 'address' },
+            { name: 'to', type: 'address' },
+            { name: 'amount', type: 'uint256' },
+        ],
+        outputs: [{ name: '', type: 'bool' }],
+        stateMutability: 'nonpayable',
+    },
+    {
+        type: 'event',
+        name: 'Transfer',
+        inputs: [
+            { name: 'from', type: 'address', indexed: true },
+            { name: 'to', type: 'address', indexed: true },
+            { name: 'value', type: 'uint256', indexed: false },
+        ],
+    },
+    {
+        type: 'event',
+        name: 'Approval',
+        inputs: [
+            { name: 'owner', type: 'address', indexed: true },
+            { name: 'spender', type: 'address', indexed: true },
+            { name: 'value', type: 'uint256', indexed: false },
+        ],
+    },
+];

package/dist/blockchain/evm/index.d.ts

@@ -0,0 +1,6 @@
+export * from './interface';
+export * from './types';
+export * from './utils';
+export * from './erc20';
+export * from './channel_hub_abi';
+export * from './client';

package/dist/blockchain/evm/index.js

@@ -0,0 +1,6 @@
+export * from './interface';
+export * from './types';
+export * from './utils';
+export * from './erc20';
+export * from './channel_hub_abi';
+export * from './client';

package/dist/blockchain/evm/interface.d.ts

@@ -0,0 +1,10 @@
+import { Address, PublicClient, WalletClient } from 'viem';
+export interface AssetStore {
+    getAssetDecimals(asset: string): Promise<number>;
+    getTokenDecimals(blockchainId: bigint, tokenAddress: Address): Promise<number>;
+    getTokenAddress(asset: string, blockchainId: bigint): Promise<Address>;
+}
+export interface EVMClient extends PublicClient {
+}
+export interface WalletSigner extends WalletClient {
+}

package/dist/blockchain/evm/interface.js

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

package/dist/blockchain/evm/types.d.ts

@@ -0,0 +1,27 @@
+import { Address } from 'viem';
+export interface ChannelDefinition {
+    challengeDuration: number;
+    user: Address;
+    node: Address;
+    nonce: bigint;
+    approvedSignatureValidators: bigint;
+    metadata: `0x${string}`;
+}
+export interface Ledger {
+    chainId: bigint;
+    token: Address;
+    decimals: number;
+    userAllocation: bigint;
+    userNetFlow: bigint;
+    nodeAllocation: bigint;
+    nodeNetFlow: bigint;
+}
+export interface State {
+    version: bigint;
+    intent: number;
+    metadata: `0x${string}`;
+    homeLedger: Ledger;
+    nonHomeLedger: Ledger;
+    userSig: `0x${string}`;
+    nodeSig: `0x${string}`;
+}

package/dist/blockchain/evm/types.js

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

package/dist/blockchain/evm/utils.d.ts

@@ -0,0 +1,9 @@
+import { Address } from 'viem';
+import * as core from '../../core/types';
+import { ChannelDefinition, Ledger, State } from './types';
+export declare function hexToBytes32(s: string): Uint8Array;
+export declare function coreDefToContractDef(def: core.ChannelDefinition, asset: string, userWallet: Address, nodeAddress: Address): ChannelDefinition;
+export declare function coreStateToContractState(state: core.State, tokenGetter: (blockchainId: bigint, tokenAddress: Address) => Promise<number>): Promise<State>;
+export declare function coreLedgerToContractLedger(ledger: core.Ledger, decimals: number): Ledger;
+export declare function contractStateToCoreState(contractState: State, homeChannelId: string, escrowChannelId?: string): core.State;
+export declare function contractLedgerToCoreLedger(ledger: Ledger): core.Ledger;

package/dist/blockchain/evm/utils.js

@@ -0,0 +1,129 @@
+import { hexToBytes } from 'viem';
+import Decimal from 'decimal.js';
+import * as core from '../../core/types';
+import { decimalToBigInt, generateChannelMetadata, getStateTransitionHash } from '../../core/utils';
+export function hexToBytes32(s) {
+    const bytes = hexToBytes(s);
+    if (bytes.length !== 32) {
+        throw new Error(`invalid length: expected 32 bytes, got ${bytes.length}`);
+    }
+    return bytes;
+}
+export function coreDefToContractDef(def, asset, userWallet, nodeAddress) {
+    return {
+        challengeDuration: def.challenge,
+        user: userWallet,
+        node: nodeAddress,
+        nonce: def.nonce,
+        approvedSignatureValidators: BigInt(def.approvedSigValidators || '0x00'),
+        metadata: generateChannelMetadata(asset),
+    };
+}
+export async function coreStateToContractState(state, tokenGetter) {
+    const homeDecimals = await tokenGetter(state.homeLedger.blockchainId, state.homeLedger.tokenAddress);
+    const homeLedger = coreLedgerToContractLedger(state.homeLedger, homeDecimals);
+    let nonHomeLedger;
+    if (state.escrowLedger) {
+        const nonHomeDecimals = await tokenGetter(state.escrowLedger.blockchainId, state.escrowLedger.tokenAddress);
+        nonHomeLedger = coreLedgerToContractLedger(state.escrowLedger, nonHomeDecimals);
+    }
+    else {
+        nonHomeLedger = {
+            chainId: 0n,
+            token: '0x0000000000000000000000000000000000000000',
+            decimals: 0,
+            userAllocation: 0n,
+            userNetFlow: 0n,
+            nodeAllocation: 0n,
+            nodeNetFlow: 0n,
+        };
+    }
+    const intent = transitionTypeToIntent(state.transition.type);
+    const metadata = getStateTransitionHash(state.transition);
+    const userSig = state.userSig ? state.userSig : '0x';
+    const nodeSig = state.nodeSig ? state.nodeSig : '0x';
+    return {
+        version: state.version,
+        intent,
+        metadata,
+        homeLedger: homeLedger,
+        nonHomeLedger: nonHomeLedger,
+        userSig,
+        nodeSig,
+    };
+}
+export function coreLedgerToContractLedger(ledger, decimals) {
+    const userAllocation = decimalToBigInt(ledger.userBalance, decimals);
+    const userNetFlow = decimalToBigInt(ledger.userNetFlow, decimals);
+    const nodeAllocation = decimalToBigInt(ledger.nodeBalance, decimals);
+    const nodeNetFlow = decimalToBigInt(ledger.nodeNetFlow, decimals);
+    return {
+        chainId: ledger.blockchainId,
+        token: ledger.tokenAddress,
+        decimals,
+        userAllocation,
+        userNetFlow,
+        nodeAllocation,
+        nodeNetFlow,
+    };
+}
+export function contractStateToCoreState(contractState, homeChannelId, escrowChannelId) {
+    const homeLedger = contractLedgerToCoreLedger(contractState.homeLedger);
+    let escrowLedger;
+    if (contractState.nonHomeLedger.chainId !== 0n) {
+        escrowLedger = contractLedgerToCoreLedger(contractState.nonHomeLedger);
+    }
+    const homeChannelIdPtr = homeChannelId || undefined;
+    const escrowChannelIdPtr = escrowChannelId || undefined;
+    let userSig;
+    let nodeSig;
+    if (contractState.userSig && contractState.userSig !== '0x') {
+        userSig = contractState.userSig;
+    }
+    if (contractState.nodeSig && contractState.nodeSig !== '0x') {
+        nodeSig = contractState.nodeSig;
+    }
+    return {
+        id: '',
+        transition: { type: core.TransitionType.Void, txId: '', amount: new Decimal(0) },
+        asset: '',
+        userWallet: '0x0000000000000000000000000000000000000000',
+        epoch: 0n,
+        version: contractState.version,
+        homeChannelId: homeChannelIdPtr,
+        escrowChannelId: escrowChannelIdPtr,
+        homeLedger,
+        escrowLedger,
+        userSig,
+        nodeSig,
+    };
+}
+export function contractLedgerToCoreLedger(ledger) {
+    const exp = -ledger.decimals;
+    return {
+        blockchainId: ledger.chainId,
+        tokenAddress: ledger.token,
+        userBalance: new Decimal(ledger.userAllocation.toString()).mul(Decimal.pow(10, exp)),
+        userNetFlow: new Decimal(ledger.userNetFlow.toString()).mul(Decimal.pow(10, exp)),
+        nodeBalance: new Decimal(ledger.nodeAllocation.toString()).mul(Decimal.pow(10, exp)),
+        nodeNetFlow: new Decimal(ledger.nodeNetFlow.toString()).mul(Decimal.pow(10, exp)),
+    };
+}
+function transitionTypeToIntent(transitionType) {
+    switch (transitionType) {
+        case core.TransitionType.HomeDeposit:
+            return core.INTENT_DEPOSIT;
+        case core.TransitionType.HomeWithdrawal:
+            return core.INTENT_WITHDRAW;
+        case core.TransitionType.Finalize:
+            return core.INTENT_CLOSE;
+        case core.TransitionType.EscrowDeposit:
+            return core.INTENT_INITIATE_ESCROW_DEPOSIT;
+        case core.TransitionType.EscrowWithdraw:
+            return core.INTENT_INITIATE_ESCROW_WITHDRAWAL;
+        case core.TransitionType.Migrate:
+            return core.INTENT_INITIATE_MIGRATION;
+        default:
+            return core.INTENT_OPERATE;
+    }
+}

package/dist/blockchain/index.d.ts

@@ -0,0 +1 @@
+export * as evm from './evm';

package/dist/blockchain/index.js

@@ -0,0 +1 @@
+export * as evm from './evm';

package/dist/client.d.ts

@@ -0,0 +1,99 @@
+import { Address, Hex } from 'viem';
+import Decimal from 'decimal.js';
+import * as core from './core';
+import * as app from './app';
+import { ChannelSessionKeyStateV1 } from './rpc/types';
+import { Option } from './config';
+import { StateSigner, TransactionSigner } from './signers';
+export declare const DEFAULT_CHALLENGE_PERIOD = 86400;
+export type { StateSigner, TransactionSigner };
+export declare class Client {
+    private rpcClient;
+    private config;
+    private exitPromise;
+    private exitResolve?;
+    private blockchainClients;
+    private homeBlockchains;
+    private stateSigner;
+    private txSigner;
+    private assetStore;
+    private constructor();
+    static create(wsURL: string, stateSigner: StateSigner, txSigner: TransactionSigner, ...opts: Option[]): Promise<Client>;
+    setHomeBlockchain(asset: string, blockchainId: bigint): Promise<void>;
+    close(): Promise<void>;
+    waitForClose(): Promise<void>;
+    signState(state: core.State): Promise<Hex>;
+    getUserAddress(): Address;
+    private signAndSubmitState;
+    deposit(blockchainId: bigint, asset: string, amount: Decimal): Promise<core.State>;
+    withdraw(blockchainId: bigint, asset: string, amount: Decimal): Promise<core.State>;
+    transfer(recipientWallet: string, asset: string, amount: Decimal): Promise<core.State>;
+    acknowledge(asset: string): Promise<core.State>;
+    closeHomeChannel(asset: string): Promise<core.State>;
+    checkpoint(asset: string): Promise<string>;
+    challenge(state: core.State): Promise<string>;
+    approveToken(chainId: bigint, asset: string, amount: Decimal): Promise<string>;
+    checkTokenAllowance(chainId: bigint, tokenAddress: string, owner: string): Promise<bigint>;
+    ping(): Promise<void>;
+    getConfig(): Promise<core.NodeConfig>;
+    getBlockchains(): Promise<core.Blockchain[]>;
+    getAssets(blockchainId?: bigint): Promise<core.Asset[]>;
+    getBalances(wallet: Address): Promise<core.BalanceEntry[]>;
+    getTransactions(wallet: Address, options?: {
+        asset?: string;
+        txType?: core.TransactionType;
+        fromTime?: bigint;
+        toTime?: bigint;
+        page?: number;
+        pageSize?: number;
+    }): Promise<{
+        transactions: core.Transaction[];
+        metadata: core.PaginationMetadata;
+    }>;
+    getChannels(wallet: Address, options?: {
+        status?: string;
+        asset?: string;
+        channelType?: string;
+        pagination?: core.PaginationParams;
+    }): Promise<{
+        channels: core.Channel[];
+        metadata: core.PaginationMetadata;
+    }>;
+    getHomeChannel(wallet: Address, asset: string): Promise<core.Channel>;
+    getEscrowChannel(escrowChannelId: string): Promise<core.Channel>;
+    getLatestState(wallet: Address, asset: string, onlySigned: boolean): Promise<core.State>;
+    getAppSessions(options?: {
+        appSessionId?: string;
+        wallet?: Address;
+        status?: string;
+        page?: number;
+        pageSize?: number;
+    }): Promise<{
+        sessions: app.AppSessionInfoV1[];
+        metadata: core.PaginationMetadata;
+    }>;
+    getAppDefinition(appSessionId: string): Promise<app.AppDefinitionV1>;
+    createAppSession(definition: app.AppDefinitionV1, sessionData: string, quorumSigs: string[]): Promise<{
+        appSessionId: string;
+        version: string;
+        status: string;
+    }>;
+    submitAppSessionDeposit(appStateUpdate: app.AppStateUpdateV1, quorumSigs: string[], asset: string, depositAmount: Decimal): Promise<string>;
+    submitAppState(appStateUpdate: app.AppStateUpdateV1, quorumSigs: string[]): Promise<void>;
+    rebalanceAppSessions(signedUpdates: app.SignedAppStateUpdateV1[]): Promise<string>;
+    signChannelSessionKeyState(state: ChannelSessionKeyStateV1): Promise<Hex>;
+    submitChannelSessionKeyState(state: ChannelSessionKeyStateV1): Promise<void>;
+    getLastChannelKeyStates(userAddress: string, sessionKey?: string): Promise<ChannelSessionKeyStateV1[]>;
+    signSessionKeyState(state: app.AppSessionKeyStateV1): Promise<Hex>;
+    submitSessionKeyState(state: app.AppSessionKeyStateV1): Promise<void>;
+    getLastKeyStates(userAddress: string, sessionKey?: string): Promise<app.AppSessionKeyStateV1[]>;
+    private initializeBlockchainClient;
+    private buildSigValidatorsBitmap;
+    private getSupportedSigValidatorsBitmap;
+    private getNodeAddress;
+    private submitState;
+    private requestChannelCreation;
+    private transformStateToRPC;
+    private transformChannelDefinitionToRPC;
+    private transitionTypeToString;
+}