@yellow-org/sdk 1.0.1-alpha.0

package/dist/rpc/api.d.ts

@@ -0,0 +1,181 @@
+import { Address } from 'viem';
+import { ChannelV1, ChannelDefinitionV1, ChannelSessionKeyStateV1, StateV1, BalanceEntryV1, TransactionV1, PaginationParamsV1, PaginationMetadataV1, AssetV1, BlockchainInfoV1 } from './types';
+import { AppDefinitionV1, AppStateUpdateV1, AppSessionInfoV1, AppAllocationV1, AppSessionKeyStateV1, SignedAppStateUpdateV1 } from '../app/types';
+import { TransactionType } from '../core/types';
+export interface ChannelsV1GetHomeChannelRequest {
+    wallet: Address;
+    asset: string;
+}
+export interface ChannelsV1GetHomeChannelResponse {
+    channel: ChannelV1;
+}
+export interface ChannelsV1GetEscrowChannelRequest {
+    escrow_channel_id: string;
+}
+export interface ChannelsV1GetEscrowChannelResponse {
+    channel: ChannelV1;
+}
+export interface ChannelsV1GetChannelsRequest {
+    wallet: Address;
+    status?: string;
+    asset?: string;
+    channel_type?: string;
+    pagination?: PaginationParamsV1;
+}
+export interface ChannelsV1GetChannelsResponse {
+    channels: ChannelV1[];
+    metadata: PaginationMetadataV1;
+}
+export interface ChannelsV1GetLatestStateRequest {
+    wallet: Address;
+    asset: string;
+    only_signed: boolean;
+}
+export interface ChannelsV1GetLatestStateResponse {
+    state: StateV1;
+}
+export interface ChannelsV1GetStatesRequest {
+    wallet: Address;
+    asset: string;
+    epoch?: bigint;
+    channel_id?: string;
+    only_signed: boolean;
+    pagination?: PaginationParamsV1;
+}
+export interface ChannelsV1GetStatesResponse {
+    states: StateV1[];
+    metadata: PaginationMetadataV1;
+}
+export interface ChannelsV1RequestCreationRequest {
+    state: StateV1;
+    channel_definition: ChannelDefinitionV1;
+}
+export interface ChannelsV1RequestCreationResponse {
+    signature: string;
+}
+export interface ChannelsV1SubmitStateRequest {
+    state: StateV1;
+}
+export interface ChannelsV1SubmitStateResponse {
+    signature: string;
+}
+export interface ChannelsV1HomeChannelCreatedEvent {
+    channel: ChannelV1;
+    initial_state: StateV1;
+}
+export interface ChannelsV1SubmitSessionKeyStateRequest {
+    state: ChannelSessionKeyStateV1;
+}
+export interface ChannelsV1SubmitSessionKeyStateResponse {
+}
+export interface ChannelsV1GetLastKeyStatesRequest {
+    user_address: string;
+    session_key?: string;
+}
+export interface ChannelsV1GetLastKeyStatesResponse {
+    states: ChannelSessionKeyStateV1[];
+}
+export interface AppSessionsV1SubmitDepositStateRequest {
+    app_state_update: AppStateUpdateV1;
+    quorum_sigs: string[];
+    user_state: StateV1;
+}
+export interface AppSessionsV1SubmitDepositStateResponse {
+    signature: string;
+}
+export interface AppSessionsV1SubmitAppStateRequest {
+    app_state_update: AppStateUpdateV1;
+    quorum_sigs: string[];
+}
+export interface AppSessionsV1SubmitAppStateResponse {
+}
+export interface AppSessionsV1RebalanceAppSessionsRequest {
+    signed_updates: SignedAppStateUpdateV1[];
+}
+export interface AppSessionsV1RebalanceAppSessionsResponse {
+    batch_id: string;
+}
+export interface AppSessionsV1GetAppDefinitionRequest {
+    app_session_id: string;
+}
+export interface AppSessionsV1GetAppDefinitionResponse {
+    definition: AppDefinitionV1;
+}
+export interface AppSessionsV1GetAppSessionsRequest {
+    app_session_id?: string;
+    participant?: Address;
+    status?: string;
+    pagination?: PaginationParamsV1;
+}
+export interface AppSessionsV1GetAppSessionsResponse {
+    app_sessions: AppSessionInfoV1[];
+    metadata: PaginationMetadataV1;
+}
+export interface AppSessionsV1CreateAppSessionRequest {
+    definition: AppDefinitionV1;
+    session_data: string;
+    quorum_sigs?: string[];
+}
+export interface AppSessionsV1CreateAppSessionResponse {
+    app_session_id: string;
+    version: string;
+    status: string;
+}
+export interface AppSessionsV1CloseAppSessionRequest {
+    app_session_id: string;
+    allocations: AppAllocationV1[];
+    session_data?: string;
+}
+export interface AppSessionsV1CloseAppSessionResponse {
+    app_session_id: string;
+    version: string;
+    status: string;
+}
+export interface AppSessionsV1SubmitSessionKeyStateRequest {
+    state: AppSessionKeyStateV1;
+}
+export interface AppSessionsV1SubmitSessionKeyStateResponse {
+}
+export interface AppSessionsV1GetLastKeyStatesRequest {
+    user_address: string;
+    session_key?: string;
+}
+export interface AppSessionsV1GetLastKeyStatesResponse {
+    states: AppSessionKeyStateV1[];
+}
+export interface UserV1GetBalancesRequest {
+    wallet: Address;
+}
+export interface UserV1GetBalancesResponse {
+    balances: BalanceEntryV1[];
+}
+export interface UserV1GetTransactionsRequest {
+    wallet: Address;
+    asset?: string;
+    tx_type?: TransactionType;
+    pagination?: PaginationParamsV1;
+    from_time?: bigint;
+    to_time?: bigint;
+}
+export interface UserV1GetTransactionsResponse {
+    transactions: TransactionV1[];
+    metadata: PaginationMetadataV1;
+}
+export interface NodeV1PingRequest {
+}
+export interface NodeV1PingResponse {
+}
+export interface NodeV1GetConfigRequest {
+}
+export interface NodeV1GetConfigResponse {
+    node_address: Address;
+    node_version: string;
+    supported_sig_validators: number[];
+    blockchains: BlockchainInfoV1[];
+}
+export interface NodeV1GetAssetsRequest {
+    blockchain_id?: bigint;
+}
+export interface NodeV1GetAssetsResponse {
+    assets: AssetV1[];
+}

package/dist/rpc/api.js

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

package/dist/rpc/client.d.ts

@@ -0,0 +1,36 @@
+import { Dialer } from './dialer';
+import { Message } from './message';
+import * as API from './api';
+export declare class RPCClient {
+    private dialer;
+    constructor(dialer: Dialer);
+    start(url: string, handleClosure: (err?: Error) => void): Promise<void>;
+    private call;
+    channelsV1GetHomeChannel(req: API.ChannelsV1GetHomeChannelRequest, signal?: AbortSignal): Promise<API.ChannelsV1GetHomeChannelResponse>;
+    channelsV1GetEscrowChannel(req: API.ChannelsV1GetEscrowChannelRequest, signal?: AbortSignal): Promise<API.ChannelsV1GetEscrowChannelResponse>;
+    channelsV1GetChannels(req: API.ChannelsV1GetChannelsRequest, signal?: AbortSignal): Promise<API.ChannelsV1GetChannelsResponse>;
+    channelsV1GetLatestState(req: API.ChannelsV1GetLatestStateRequest, signal?: AbortSignal): Promise<API.ChannelsV1GetLatestStateResponse>;
+    channelsV1GetStates(req: API.ChannelsV1GetStatesRequest, signal?: AbortSignal): Promise<API.ChannelsV1GetStatesResponse>;
+    channelsV1RequestCreation(req: API.ChannelsV1RequestCreationRequest, signal?: AbortSignal): Promise<API.ChannelsV1RequestCreationResponse>;
+    channelsV1SubmitState(req: API.ChannelsV1SubmitStateRequest, signal?: AbortSignal): Promise<API.ChannelsV1SubmitStateResponse>;
+    channelsV1SubmitSessionKeyState(req: API.ChannelsV1SubmitSessionKeyStateRequest, signal?: AbortSignal): Promise<API.ChannelsV1SubmitSessionKeyStateResponse>;
+    channelsV1GetLastKeyStates(req: API.ChannelsV1GetLastKeyStatesRequest, signal?: AbortSignal): Promise<API.ChannelsV1GetLastKeyStatesResponse>;
+    appSessionsV1SubmitDepositState(req: API.AppSessionsV1SubmitDepositStateRequest, signal?: AbortSignal): Promise<API.AppSessionsV1SubmitDepositStateResponse>;
+    appSessionsV1SubmitAppState(req: API.AppSessionsV1SubmitAppStateRequest, signal?: AbortSignal): Promise<API.AppSessionsV1SubmitAppStateResponse>;
+    appSessionsV1RebalanceAppSessions(req: API.AppSessionsV1RebalanceAppSessionsRequest, signal?: AbortSignal): Promise<API.AppSessionsV1RebalanceAppSessionsResponse>;
+    appSessionsV1GetAppDefinition(req: API.AppSessionsV1GetAppDefinitionRequest, signal?: AbortSignal): Promise<API.AppSessionsV1GetAppDefinitionResponse>;
+    appSessionsV1GetAppSessions(req: API.AppSessionsV1GetAppSessionsRequest, signal?: AbortSignal): Promise<API.AppSessionsV1GetAppSessionsResponse>;
+    appSessionsV1CreateAppSession(req: API.AppSessionsV1CreateAppSessionRequest, signal?: AbortSignal): Promise<API.AppSessionsV1CreateAppSessionResponse>;
+    appSessionsV1CloseAppSession(req: API.AppSessionsV1CloseAppSessionRequest, signal?: AbortSignal): Promise<API.AppSessionsV1CloseAppSessionResponse>;
+    appSessionsV1SubmitSessionKeyState(req: API.AppSessionsV1SubmitSessionKeyStateRequest, signal?: AbortSignal): Promise<API.AppSessionsV1SubmitSessionKeyStateResponse>;
+    appSessionsV1GetLastKeyStates(req: API.AppSessionsV1GetLastKeyStatesRequest, signal?: AbortSignal): Promise<API.AppSessionsV1GetLastKeyStatesResponse>;
+    userV1GetBalances(req: API.UserV1GetBalancesRequest, signal?: AbortSignal): Promise<API.UserV1GetBalancesResponse>;
+    userV1GetTransactions(req: API.UserV1GetTransactionsRequest, signal?: AbortSignal): Promise<API.UserV1GetTransactionsResponse>;
+    nodeV1Ping(signal?: AbortSignal): Promise<void>;
+    nodeV1GetConfig(signal?: AbortSignal): Promise<API.NodeV1GetConfigResponse>;
+    nodeV1GetAssets(req: API.NodeV1GetAssetsRequest, signal?: AbortSignal): Promise<API.NodeV1GetAssetsResponse>;
+    close(): Promise<void>;
+    isConnected(): boolean;
+    eventChannel(): AsyncIterable<Message>;
+}
+export declare function newRPCClient(dialer: Dialer): RPCClient;

package/dist/rpc/client.js

@@ -0,0 +1,102 @@
+import { newRequest, newPayload, messageError, translatePayload } from './message';
+import * as Methods from './methods';
+export class RPCClient {
+    constructor(dialer) {
+        this.dialer = dialer;
+    }
+    async start(url, handleClosure) {
+        return this.dialer.dial(url, handleClosure);
+    }
+    async call(method, req, signal) {
+        const requestId = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
+        const payload = newPayload(req);
+        const message = newRequest(requestId, method, payload);
+        const response = await this.dialer.call(message, signal);
+        const err = messageError(response);
+        if (err) {
+            throw new Error(`rpc returned error: ${err.message}`);
+        }
+        return translatePayload(response.payload);
+    }
+    async channelsV1GetHomeChannel(req, signal) {
+        return this.call(Methods.ChannelsV1GetHomeChannelMethod, req, signal);
+    }
+    async channelsV1GetEscrowChannel(req, signal) {
+        return this.call(Methods.ChannelsV1GetEscrowChannelMethod, req, signal);
+    }
+    async channelsV1GetChannels(req, signal) {
+        return this.call(Methods.ChannelsV1GetChannelsMethod, req, signal);
+    }
+    async channelsV1GetLatestState(req, signal) {
+        return this.call(Methods.ChannelsV1GetLatestStateMethod, req, signal);
+    }
+    async channelsV1GetStates(req, signal) {
+        return this.call(Methods.ChannelsV1GetStatesMethod, req, signal);
+    }
+    async channelsV1RequestCreation(req, signal) {
+        return this.call(Methods.ChannelsV1RequestCreationMethod, req, signal);
+    }
+    async channelsV1SubmitState(req, signal) {
+        return this.call(Methods.ChannelsV1SubmitStateMethod, req, signal);
+    }
+    async channelsV1SubmitSessionKeyState(req, signal) {
+        return this.call(Methods.ChannelsV1SubmitSessionKeyStateMethod, req, signal);
+    }
+    async channelsV1GetLastKeyStates(req, signal) {
+        return this.call(Methods.ChannelsV1GetLastKeyStatesMethod, req, signal);
+    }
+    async appSessionsV1SubmitDepositState(req, signal) {
+        return this.call(Methods.AppSessionsV1SubmitDepositStateMethod, req, signal);
+    }
+    async appSessionsV1SubmitAppState(req, signal) {
+        return this.call(Methods.AppSessionsV1SubmitAppStateMethod, req, signal);
+    }
+    async appSessionsV1RebalanceAppSessions(req, signal) {
+        return this.call(Methods.AppSessionsV1RebalanceAppSessionsMethod, req, signal);
+    }
+    async appSessionsV1GetAppDefinition(req, signal) {
+        return this.call(Methods.AppSessionsV1GetAppDefinitionMethod, req, signal);
+    }
+    async appSessionsV1GetAppSessions(req, signal) {
+        return this.call(Methods.AppSessionsV1GetAppSessionsMethod, req, signal);
+    }
+    async appSessionsV1CreateAppSession(req, signal) {
+        return this.call(Methods.AppSessionsV1CreateAppSessionMethod, req, signal);
+    }
+    async appSessionsV1CloseAppSession(req, signal) {
+        return this.call(Methods.AppSessionsV1CloseAppSessionMethod, req, signal);
+    }
+    async appSessionsV1SubmitSessionKeyState(req, signal) {
+        return this.call(Methods.AppSessionsV1SubmitSessionKeyStateMethod, req, signal);
+    }
+    async appSessionsV1GetLastKeyStates(req, signal) {
+        return this.call(Methods.AppSessionsV1GetLastKeyStatesMethod, req, signal);
+    }
+    async userV1GetBalances(req, signal) {
+        return this.call(Methods.UserV1GetBalancesMethod, req, signal);
+    }
+    async userV1GetTransactions(req, signal) {
+        return this.call(Methods.UserV1GetTransactionsMethod, req, signal);
+    }
+    async nodeV1Ping(signal) {
+        await this.call(Methods.NodeV1PingMethod, {}, signal);
+    }
+    async nodeV1GetConfig(signal) {
+        return this.call(Methods.NodeV1GetConfigMethod, {}, signal);
+    }
+    async nodeV1GetAssets(req, signal) {
+        return this.call(Methods.NodeV1GetAssetsMethod, req, signal);
+    }
+    async close() {
+        return this.dialer.close();
+    }
+    isConnected() {
+        return this.dialer.isConnected();
+    }
+    eventChannel() {
+        return this.dialer.eventChannel();
+    }
+}
+export function newRPCClient(dialer) {
+    return new RPCClient(dialer);
+}

package/dist/rpc/dialer.d.ts

@@ -0,0 +1,30 @@
+import { Message } from './message';
+export interface Dialer {
+    dial(url: string, handleClosure: (err?: Error) => void): Promise<void>;
+    isConnected(): boolean;
+    call(req: Message, signal?: AbortSignal): Promise<Message>;
+    eventChannel(): AsyncIterable<Message>;
+    close(): Promise<void>;
+}
+export interface WebsocketDialerConfig {
+    handshakeTimeout: number;
+    eventChanSize: number;
+}
+export declare const DefaultWebsocketDialerConfig: WebsocketDialerConfig;
+export declare class WebsocketDialer implements Dialer {
+    private config;
+    private ws;
+    private responseSinks;
+    private eventQueue;
+    private eventResolvers;
+    private closeHandler?;
+    constructor(config?: WebsocketDialerConfig);
+    dial(url: string, handleClosure: (err?: Error) => void): Promise<void>;
+    isConnected(): boolean;
+    call(req: Message, signal?: AbortSignal): Promise<Message>;
+    eventChannel(): AsyncIterable<Message>;
+    close(): Promise<void>;
+    private handleMessage;
+    private handleClose;
+}
+export declare function newWebsocketDialer(config?: WebsocketDialerConfig): WebsocketDialer;

package/dist/rpc/dialer.js

@@ -0,0 +1,146 @@
+import { marshalMessage, unmarshalMessage } from './message';
+import { ErrAlreadyConnected, ErrNotConnected } from './error';
+export const DefaultWebsocketDialerConfig = {
+    handshakeTimeout: 5000,
+    eventChanSize: 100,
+};
+export class WebsocketDialer {
+    constructor(config = DefaultWebsocketDialerConfig) {
+        this.ws = null;
+        this.responseSinks = new Map();
+        this.eventQueue = [];
+        this.eventResolvers = [];
+        this.config = config;
+    }
+    async dial(url, handleClosure) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            throw ErrAlreadyConnected;
+        }
+        this.closeHandler = handleClosure;
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(url);
+            const timeout = setTimeout(() => {
+                ws.close();
+                reject(new Error('WebSocket handshake timeout'));
+            }, this.config.handshakeTimeout);
+            ws.onopen = () => {
+                clearTimeout(timeout);
+                this.ws = ws;
+                resolve();
+            };
+            ws.onerror = () => {
+                clearTimeout(timeout);
+                const error = new Error('WebSocket error');
+                if (this.ws === ws) {
+                    this.handleClose(error);
+                }
+                reject(error);
+            };
+            ws.onclose = () => {
+                clearTimeout(timeout);
+                if (this.ws === ws) {
+                    this.handleClose();
+                }
+            };
+            ws.onmessage = (event) => {
+                this.handleMessage(event.data);
+            };
+        });
+    }
+    isConnected() {
+        return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+    }
+    async call(req, signal) {
+        if (!this.isConnected()) {
+            throw ErrNotConnected;
+        }
+        return new Promise((resolve, reject) => {
+            if (signal?.aborted) {
+                reject(new Error('Request aborted'));
+                return;
+            }
+            const abortHandler = () => {
+                this.responseSinks.delete(req.requestId);
+                reject(new Error('Request aborted'));
+            };
+            signal?.addEventListener('abort', abortHandler, { once: true });
+            this.responseSinks.set(req.requestId, (msg) => {
+                signal?.removeEventListener('abort', abortHandler);
+                resolve(msg);
+            });
+            try {
+                const data = marshalMessage(req);
+                this.ws.send(data);
+            }
+            catch (error) {
+                this.responseSinks.delete(req.requestId);
+                signal?.removeEventListener('abort', abortHandler);
+                reject(error);
+            }
+        });
+    }
+    async *eventChannel() {
+        while (this.isConnected()) {
+            if (this.eventQueue.length > 0) {
+                const event = this.eventQueue.shift();
+                yield event;
+            }
+            else {
+                const event = await new Promise((resolve) => {
+                    this.eventResolvers.push(resolve);
+                });
+                yield event;
+            }
+        }
+    }
+    async close() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+    handleMessage(data) {
+        try {
+            const msg = unmarshalMessage(data);
+            const sink = this.responseSinks.get(msg.requestId);
+            if (sink) {
+                this.responseSinks.delete(msg.requestId);
+                sink(msg);
+            }
+            else {
+                if (this.eventResolvers.length > 0) {
+                    const resolver = this.eventResolvers.shift();
+                    resolver(msg);
+                }
+                else {
+                    this.eventQueue.push(msg);
+                    if (this.eventQueue.length > this.config.eventChanSize) {
+                        this.eventQueue.shift();
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('Failed to parse WebSocket message:', error);
+        }
+    }
+    handleClose(error) {
+        this.ws = null;
+        for (const [id, sink] of this.responseSinks.entries()) {
+            sink({
+                type: 4,
+                requestId: id,
+                method: '',
+                payload: { error: 'Connection closed' },
+                timestamp: Date.now(),
+            });
+        }
+        this.responseSinks.clear();
+        if (this.closeHandler) {
+            this.closeHandler(error);
+        }
+    }
+}
+export function newWebsocketDialer(config = DefaultWebsocketDialerConfig) {
+    return new WebsocketDialer(config);
+}

package/dist/rpc/error.d.ts

@@ -0,0 +1,18 @@
+import { Payload } from './message';
+export declare const ERROR_PARAM_KEY = "error";
+export declare class RPCError extends Error {
+    constructor(message: string);
+}
+export declare const ErrAlreadyConnected: RPCError;
+export declare const ErrNotConnected: RPCError;
+export declare const ErrConnectionTimeout: RPCError;
+export declare const ErrReadingMessage: RPCError;
+export declare const ErrNilRequest: RPCError;
+export declare const ErrInvalidRequestMethod: RPCError;
+export declare const ErrMarshalingRequest: RPCError;
+export declare const ErrSendingRequest: RPCError;
+export declare const ErrNoResponse: RPCError;
+export declare const ErrSendingPing: RPCError;
+export declare const ErrDialingWebsocket: RPCError;
+export declare function newErrorPayload(errMsg: string): Payload;
+export declare function errorf(format: string, ...args: unknown[]): RPCError;

package/dist/rpc/error.js

@@ -0,0 +1,27 @@
+export const ERROR_PARAM_KEY = 'error';
+export class RPCError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'RPCError';
+    }
+}
+export const ErrAlreadyConnected = new RPCError('already connected');
+export const ErrNotConnected = new RPCError('not connected');
+export const ErrConnectionTimeout = new RPCError('connection timeout');
+export const ErrReadingMessage = new RPCError('error reading message');
+export const ErrNilRequest = new RPCError('nil request');
+export const ErrInvalidRequestMethod = new RPCError('invalid request method');
+export const ErrMarshalingRequest = new RPCError('error marshaling request');
+export const ErrSendingRequest = new RPCError('error sending request');
+export const ErrNoResponse = new RPCError('no response received');
+export const ErrSendingPing = new RPCError('error sending ping');
+export const ErrDialingWebsocket = new RPCError('error dialing websocket');
+export function newErrorPayload(errMsg) {
+    return {
+        [ERROR_PARAM_KEY]: errMsg,
+    };
+}
+export function errorf(format, ...args) {
+    const message = format.replace(/%s/g, () => String(args.shift() || ''));
+    return new RPCError(message);
+}

package/dist/rpc/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types';
+export * from './api';
+export * from './client';
+export * from './methods';
+export * from './message';
+export * from './dialer';
+export * from './error';

package/dist/rpc/index.js

@@ -0,0 +1,7 @@
+export * from './types';
+export * from './api';
+export * from './client';
+export * from './methods';
+export * from './message';
+export * from './dialer';
+export * from './error';

package/dist/rpc/message.d.ts

@@ -0,0 +1,25 @@
+export declare enum MsgType {
+    Req = 1,
+    Resp = 2,
+    Event = 3,
+    RespErr = 4
+}
+export type Payload = Record<string, unknown>;
+export interface Message {
+    type: MsgType;
+    requestId: number;
+    method: string;
+    payload: Payload;
+    timestamp: number;
+}
+export declare function newPayload(v: unknown): Payload;
+export declare function translatePayload<T>(payload: Payload): T;
+export declare function payloadError(payload: Payload): Error | null;
+export declare function messageError(message: Message): Error | null;
+export declare function newMessage(type: MsgType, requestId: number, method: string, payload?: Payload): Message;
+export declare function newRequest(requestId: number, method: string, payload?: Payload): Message;
+export declare function newResponse(requestId: number, method: string, payload?: Payload): Message;
+export declare function newEvent(requestId: number, method: string, payload?: Payload): Message;
+export declare function newErrorResponse(requestId: number, method: string, errMsg: string): Message;
+export declare function marshalMessage(message: Message): string;
+export declare function unmarshalMessage(data: string): Message;