raiden-ts
Version:
Raiden Light Client Typescript/Javascript SDK
620 lines (619 loc) • 18.4 kB
TypeScript
import * as t from 'io-ts';
import type { ActionType } from '../utils/actions';
import { Address, UInt } from '../utils/types';
export declare const pathFind: {
readonly request: ((payload: {
paths?: readonly Readonly<({
route: readonly Address[];
} | {
path: readonly Address[];
}) & ({
fee: import("../utils/types").Int<32>;
} | {
estimated_fee: import("../utils/types").Int<32>;
}) & {
address_metadata?: Readonly<{
[x: string]: import("./types").AddressMetadata;
}> | undefined;
}>[] | undefined;
pfs?: Readonly<{
address: Address;
url: string;
matrixServer: string;
rtt: number;
price: UInt<32>;
token: Address;
validTill: number;
}> | null | undefined;
}, meta: {
tokenNetwork: Address;
target: Address;
value: UInt<32>;
}) => {
readonly type: "path/find/request";
readonly payload: {
paths?: readonly Readonly<({
route: readonly Address[];
} | {
path: readonly Address[];
}) & ({
fee: import("../utils/types").Int<32>;
} | {
estimated_fee: import("../utils/types").Int<32>;
}) & {
address_metadata?: Readonly<{
[x: string]: import("./types").AddressMetadata;
}> | undefined;
}>[] | undefined;
pfs?: Readonly<{
address: Address;
url: string;
matrixServer: string;
rtt: number;
price: UInt<32>;
token: Address;
validTill: number;
}> | null | undefined;
};
readonly meta: {
tokenNetwork: Address;
target: Address;
value: UInt<32>;
};
}) & {
type: "path/find/request";
codec: t.Mixed;
is: (a: unknown) => a is {
readonly type: "path/find/request";
readonly payload: {
paths?: readonly Readonly<({
route: readonly Address[];
} | {
path: readonly Address[];
}) & ({
fee: import("../utils/types").Int<32>;
} | {
estimated_fee: import("../utils/types").Int<32>;
}) & {
address_metadata?: Readonly<{
[x: string]: import("./types").AddressMetadata;
}> | undefined;
}>[] | undefined;
pfs?: Readonly<{
address: Address;
url: string;
matrixServer: string;
rtt: number;
price: UInt<32>;
token: Address;
validTill: number;
}> | null | undefined;
};
readonly meta: {
tokenNetwork: Address;
target: Address;
value: UInt<32>;
};
};
error: undefined;
};
readonly success: ((payload: {
paths: readonly Readonly<{
path: readonly Address[];
fee: import("../utils/types").Int<32>;
} & {
address_metadata?: Readonly<{
[x: string]: import("./types").AddressMetadata;
}> | undefined;
}>[];
}, meta: {
tokenNetwork: Address;
target: Address;
value: UInt<32>;
}) => {
readonly type: "path/find/success";
readonly payload: {
paths: readonly Readonly<{
path: readonly Address[];
fee: import("../utils/types").Int<32>;
} & {
address_metadata?: Readonly<{
[x: string]: import("./types").AddressMetadata;
}> | undefined;
}>[];
};
readonly meta: {
tokenNetwork: Address;
target: Address;
value: UInt<32>;
};
}) & {
type: "path/find/success";
codec: t.Mixed;
is: (a: unknown) => a is {
readonly type: "path/find/success";
readonly payload: {
paths: readonly Readonly<{
path: readonly Address[];
fee: import("../utils/types").Int<32>;
} & {
address_metadata?: Readonly<{
[x: string]: import("./types").AddressMetadata;
}> | undefined;
}>[];
};
readonly meta: {
tokenNetwork: Address;
target: Address;
value: UInt<32>;
};
};
error: undefined;
};
readonly failure: ((payload: unknown, meta: {
tokenNetwork: Address;
target: Address;
value: UInt<32>;
}) => {
readonly type: "path/find/failure";
readonly payload: unknown;
readonly meta: {
tokenNetwork: Address;
target: Address;
value: UInt<32>;
};
readonly error: true;
}) & {
type: "path/find/failure";
codec: t.Mixed;
is: (a: unknown) => a is {
readonly type: "path/find/failure";
readonly payload: unknown;
readonly meta: {
tokenNetwork: Address;
target: Address;
value: UInt<32>;
};
readonly error: true;
};
error: true;
};
};
export declare namespace pathFind {
interface request extends ActionType<typeof pathFind.request> {
}
interface success extends ActionType<typeof pathFind.success> {
}
interface failure extends ActionType<typeof pathFind.failure> {
}
}
export declare const servicesValid: ((payload: Readonly<{
[x: string]: number;
}>) => {
readonly type: "services/valid";
readonly payload: Readonly<{
[x: string]: number;
}>;
}) & {
type: "services/valid";
codec: t.Mixed;
is: (a: unknown) => a is {
readonly type: "services/valid";
readonly payload: Readonly<{
[x: string]: number;
}>;
};
error: undefined;
};
export interface servicesValid extends ActionType<typeof servicesValid> {
}
export declare const iouPersist: ((payload: {
iou: Readonly<{
sender: Address;
receiver: Address;
amount: UInt<32>;
claimable_until: UInt<32>;
one_to_n_address: Address;
chain_id: UInt<32>;
}> & Readonly<{
signature: import("../utils/types").HexString<65>;
}>;
}, meta: {
tokenNetwork: Address;
serviceAddress: Address;
}) => {
readonly type: "iou/persist";
readonly payload: {
iou: Readonly<{
sender: Address;
receiver: Address;
amount: UInt<32>;
claimable_until: UInt<32>;
one_to_n_address: Address;
chain_id: UInt<32>;
}> & Readonly<{
signature: import("../utils/types").HexString<65>;
}>;
};
readonly meta: {
tokenNetwork: Address;
serviceAddress: Address;
};
}) & {
type: "iou/persist";
codec: t.Mixed;
is: (a: unknown) => a is {
readonly type: "iou/persist";
readonly payload: {
iou: Readonly<{
sender: Address;
receiver: Address;
amount: UInt<32>;
claimable_until: UInt<32>;
one_to_n_address: Address;
chain_id: UInt<32>;
}> & Readonly<{
signature: import("../utils/types").HexString<65>;
}>;
};
readonly meta: {
tokenNetwork: Address;
serviceAddress: Address;
};
};
error: undefined;
};
export interface iouPersist extends ActionType<typeof iouPersist> {
}
export declare const iouClear: ((_: undefined, meta: {
tokenNetwork: Address;
serviceAddress: Address;
}) => {
readonly type: "iou/clear";
readonly meta: {
tokenNetwork: Address;
serviceAddress: Address;
};
}) & {
type: "iou/clear";
codec: t.Mixed;
is: (a: unknown) => a is {
readonly type: "iou/clear";
readonly meta: {
tokenNetwork: Address;
serviceAddress: Address;
};
};
error: undefined;
};
export interface iouClear extends ActionType<typeof iouClear> {
}
export declare const udcDeposit: {
readonly request: ((payload: {
deposit: UInt<32>;
}, meta: {
totalDeposit: UInt<32>;
}) => {
readonly type: "udc/deposit/request";
readonly payload: {
deposit: UInt<32>;
};
readonly meta: {
totalDeposit: UInt<32>;
};
}) & {
type: "udc/deposit/request";
codec: t.Mixed;
is: (a: unknown) => a is {
readonly type: "udc/deposit/request";
readonly payload: {
deposit: UInt<32>;
};
readonly meta: {
totalDeposit: UInt<32>;
};
};
error: undefined;
};
readonly success: ((payload: {
balance: UInt<32>;
} | {
balance: UInt<32>;
txHash: import("../utils/types").HexString<32>;
txBlock: number;
confirmed: boolean | undefined;
}, meta: {
totalDeposit: UInt<32>;
}) => {
readonly type: "udc/deposit/success";
readonly payload: {
balance: UInt<32>;
} | {
balance: UInt<32>;
txHash: import("../utils/types").HexString<32>;
txBlock: number;
confirmed: boolean | undefined;
};
readonly meta: {
totalDeposit: UInt<32>;
};
}) & {
type: "udc/deposit/success";
codec: t.Mixed;
is: (a: unknown) => a is {
readonly type: "udc/deposit/success";
readonly payload: {
balance: UInt<32>;
} | {
balance: UInt<32>;
txHash: import("../utils/types").HexString<32>;
txBlock: number;
confirmed: boolean | undefined;
};
readonly meta: {
totalDeposit: UInt<32>;
};
};
error: undefined;
};
readonly failure: ((payload: unknown, meta: {
totalDeposit: UInt<32>;
}) => {
readonly type: "udc/deposit/failure";
readonly payload: unknown;
readonly meta: {
totalDeposit: UInt<32>;
};
readonly error: true;
}) & {
type: "udc/deposit/failure";
codec: t.Mixed;
is: (a: unknown) => a is {
readonly type: "udc/deposit/failure";
readonly payload: unknown;
readonly meta: {
totalDeposit: UInt<32>;
};
readonly error: true;
};
error: true;
};
};
export declare namespace udcDeposit {
interface request extends ActionType<typeof udcDeposit.request> {
}
interface success extends ActionType<typeof udcDeposit.success> {
}
interface failure extends ActionType<typeof udcDeposit.failure> {
}
}
export declare const udcWithdrawPlan: {
readonly request: ((payload: undefined, meta: {
amount: UInt<32>;
}) => {
readonly type: "udc/withdraw/plan/request";
readonly payload: undefined;
readonly meta: {
amount: UInt<32>;
};
}) & {
type: "udc/withdraw/plan/request";
codec: t.Mixed;
is: (a: unknown) => a is {
readonly type: "udc/withdraw/plan/request";
readonly payload: undefined;
readonly meta: {
amount: UInt<32>;
};
};
error: undefined;
};
readonly success: ((payload: {
withdrawableAfter: number;
} & {
txHash?: import("../utils/types").HexString<32> | undefined;
txBlock?: number | undefined;
confirmed?: boolean | undefined;
}, meta: {
amount: UInt<32>;
}) => {
readonly type: "udc/withdraw/plan/success";
readonly payload: {
withdrawableAfter: number;
} & {
txHash?: import("../utils/types").HexString<32> | undefined;
txBlock?: number | undefined;
confirmed?: boolean | undefined;
};
readonly meta: {
amount: UInt<32>;
};
}) & {
type: "udc/withdraw/plan/success";
codec: t.Mixed;
is: (a: unknown) => a is {
readonly type: "udc/withdraw/plan/success";
readonly payload: {
withdrawableAfter: number;
} & {
txHash?: import("../utils/types").HexString<32> | undefined;
txBlock?: number | undefined;
confirmed?: boolean | undefined;
};
readonly meta: {
amount: UInt<32>;
};
};
error: undefined;
};
readonly failure: ((payload: unknown, meta: {
amount: UInt<32>;
}) => {
readonly type: "udc/withdraw/plan/failure";
readonly payload: unknown;
readonly meta: {
amount: UInt<32>;
};
readonly error: true;
}) & {
type: "udc/withdraw/plan/failure";
codec: t.Mixed;
is: (a: unknown) => a is {
readonly type: "udc/withdraw/plan/failure";
readonly payload: unknown;
readonly meta: {
amount: UInt<32>;
};
readonly error: true;
};
error: true;
};
};
export declare namespace udcWithdrawPlan {
interface request extends ActionType<typeof udcWithdrawPlan.request> {
}
interface success extends ActionType<typeof udcWithdrawPlan.success> {
}
interface failure extends ActionType<typeof udcWithdrawPlan.failure> {
}
}
export declare const udcWithdraw: {
readonly request: ((payload: {
subkey?: boolean | undefined;
} | undefined, meta: {
amount: UInt<32>;
}) => {
readonly type: "udc/withdraw/request";
readonly payload: {
subkey?: boolean | undefined;
} | undefined;
readonly meta: {
amount: UInt<32>;
};
}) & {
type: "udc/withdraw/request";
codec: t.Mixed;
is: (a: unknown) => a is {
readonly type: "udc/withdraw/request";
readonly payload: {
subkey?: boolean | undefined;
} | undefined;
readonly meta: {
amount: UInt<32>;
};
};
error: undefined;
};
readonly success: ((payload: {
withdrawal: UInt<32>;
beneficiary: Address;
txHash: import("../utils/types").HexString<32>;
txBlock: number;
confirmed: boolean | undefined;
}, meta: {
amount: UInt<32>;
}) => {
readonly type: "udc/withdraw/success";
readonly payload: {
withdrawal: UInt<32>;
beneficiary: Address;
txHash: import("../utils/types").HexString<32>;
txBlock: number;
confirmed: boolean | undefined;
};
readonly meta: {
amount: UInt<32>;
};
}) & {
type: "udc/withdraw/success";
codec: t.Mixed;
is: (a: unknown) => a is {
readonly type: "udc/withdraw/success";
readonly payload: {
withdrawal: UInt<32>;
beneficiary: Address;
txHash: import("../utils/types").HexString<32>;
txBlock: number;
confirmed: boolean | undefined;
};
readonly meta: {
amount: UInt<32>;
};
};
error: undefined;
};
readonly failure: ((payload: unknown, meta: {
amount: UInt<32>;
}) => {
readonly type: "udc/withdraw/failure";
readonly payload: unknown;
readonly meta: {
amount: UInt<32>;
};
readonly error: true;
}) & {
type: "udc/withdraw/failure";
codec: t.Mixed;
is: (a: unknown) => a is {
readonly type: "udc/withdraw/failure";
readonly payload: unknown;
readonly meta: {
amount: UInt<32>;
};
readonly error: true;
};
error: true;
};
};
export declare namespace udcWithdraw {
interface request extends ActionType<typeof udcWithdraw.request> {
}
interface success extends ActionType<typeof udcWithdraw.success> {
}
interface failure extends ActionType<typeof udcWithdraw.failure> {
}
}
export declare const msBalanceProofSent: ((payload: {
tokenNetwork: Address;
partner: Address;
id: number;
reward: UInt<32>;
nonce: UInt<8>;
monitoringService: Address;
txHash: import("../utils/types").HexString<32>;
txBlock: number;
confirmed: boolean | undefined;
}) => {
readonly type: "ms/balanceProof/sent";
readonly payload: {
tokenNetwork: Address;
partner: Address;
id: number;
reward: UInt<32>;
nonce: UInt<8>;
monitoringService: Address;
txHash: import("../utils/types").HexString<32>;
txBlock: number;
confirmed: boolean | undefined;
};
}) & {
type: "ms/balanceProof/sent";
codec: t.Mixed;
is: (a: unknown) => a is {
readonly type: "ms/balanceProof/sent";
readonly payload: {
tokenNetwork: Address;
partner: Address;
id: number;
reward: UInt<32>;
nonce: UInt<8>;
monitoringService: Address;
txHash: import("../utils/types").HexString<32>;
txBlock: number;
confirmed: boolean | undefined;
};
};
error: undefined;
};
export interface msBalanceProofSent extends ActionType<typeof msBalanceProofSent> {
}