raiden-ts/dist/transfers/utils.d.ts

Raiden Light Client Typescript/Javascript SDK

import type { Signer } from '@ethersproject/abstract-signer';
import type { Observable } from 'rxjs';
import type { Channel } from '../channels';
import type { Lock } from '../channels/types';
import type { RaidenDatabase } from '../db/types';
import type { RouteMetadata } from '../messages/types';
import { Metadata } from '../messages/types';
import type { Fee, Paths } from '../services/types';
import type { RaidenState } from '../state';
import type { matrixPresence } from '../transport/actions';
import type { Via } from '../transport/types';
import type { Address, Hash, Secret, UInt } from '../utils/types';
import type { RaidenTransfer } from './state';
import { Direction, RaidenTransferStatus, RevealedSecret, TransferState } from './state';
/**
 * Get the locksroot of a given array of pending locks
 * On Alderaan, it's the keccak256 hash of the concatenation of the ordered locks data
 *
 * @param locks - Lock array to calculate the locksroot from
 * @returns hash of the locks array
 */
export declare function getLocksroot(locks: readonly Lock[]): Hash;
/**
 * Return the secrethash of a given secret
 * On Alderaan, the sha256 hash is used for the secret.
 *
 * @param secret - Secret to get the hash from
 * @returns hash of the secret
 */
export declare function getSecrethash(secret: Secret): Hash;
/**
 * Generates a random secret of given length, as an HexString<32>
 *
 * @param length - of the secret to generate
 * @returns HexString<32>
 */
export declare function makeSecret(length?: number): Secret;
/**
 * Generates a unique 64bits payment identifier
 *
 * @returns Unique UInt<8>
 */
export declare function makePaymentId(): UInt<8>;
/**
 * Generates a unique 64bits message identifier
 *
 * @returns Unique UInt<8>
 */
export declare function makeMessageId(): UInt<8>;
/**
 * Get a unique key for a tranfer state or TransferId
 *
 * @param state - transfer to get key from, or TransferId
 * @returns string containing a unique key for transfer
 */
export declare function transferKey(state: TransferState | {
    secrethash: Hash;
    direction: Direction;
}): string;
/**
 * Parse a transferKey into a TransferId object ({ secrethash, direction })
 *
 * @param key - string to parse as transferKey
 * @returns secrethash, direction contained in transferKey
 */
export declare function transferKeyToMeta(key: string): {
    secrethash: Hash;
    direction: Direction;
};
/**
 * @param state - Transfer state
 * @returns Transfer's status
 */
export declare function transferStatus(state: TransferState): RaidenTransferStatus;
/**
 * @param state - Transfer state
 * @returns Whether the transfer is considered completed
 */
export declare function transferCompleted(state: TransferState): state is TransferState & NonNullable<Pick<TransferState, 'unlockProcessed'> | Pick<TransferState, 'expiredProcessed'> | Pick<TransferState, 'secretRegistered'> | Pick<TransferState, 'channelSettled'>>;
/**
 * Convert a TransferState to a public RaidenTransfer object
 *
 * @param state - RaidenState.sent value
 * @returns Public raiden sent transfer info object
 */
export declare function raidenTransfer(state: TransferState): RaidenTransfer;
/**
 * Look for a BalanceProof matching given balanceHash among EnvelopeMessages in transfers
 *
 * @param db - Database instance
 * @param channel - Channel key of hash
 * @param direction - Direction of transfers to search
 * @param balanceHash - Expected balanceHash
 * @returns BalanceProof matching balanceHash or undefined
 */
export declare function findBalanceProofMatchingBalanceHash$(db: RaidenDatabase, channel: Channel, direction: Direction, balanceHash: Hash): Observable<import("../utils/types").Signed<import("../channels").BalanceProof>>;
/**
 * @param state - RaidenState or Observable of RaidenState to get transfer from
 * @param db - Try to fetch from db if not found on state
 * @param key - transferKey/_id to get
 * @returns Promise to TransferState
 */
export declare function getTransfer(state: RaidenState | Observable<RaidenState>, db: RaidenDatabase, key: string | {
    secrethash: Hash;
    direction: Direction;
}): Promise<TransferState>;
/**
 * Prune metadata route without changing any of the original encoding
 * A clear metadata route have partner (address after ours) as first hop in routes[*].route array.
 * To be used only if partner requires !Capabilities.IMMUTABLE_METADATA
 *
 * @param address - Our address
 * @param metadata - Metadata object
 * @returns A copy of metadata with routes cleared (i.e. partner as first/next address)
 */
export declare function clearMetadataRoute<M extends unknown | Metadata>(address: Address, metadata: M): M;
/**
 * Contructs transfer.request's payload paramaters from received PFS's Paths
 *
 * @param paths - Paths array coming from PFS
 * @param target - presence of target address
 * @param encryptSecret - Try to encrypt this secret object to target
 * @returns Respective members of transfer.request's payload
 */
export declare function metadataFromPaths(paths: Paths, target: matrixPresence.success, encryptSecret?: RevealedSecret): Readonly<{
    resolved: true;
    fee: Fee;
    partner: Address;
    metadata: unknown;
} & Via>;
/**
 * @param metadata - Undecoded metadata
 * @param transfer - Transfer info
 * @param transfer."0" - Transfer's secrethash
 * @param transfer."1" - Transfer's effective received amount
 * @param transfer."2" - Transfer's paymendId
 * @param signer - Our effective signer (with `privateKey`)
 * @returns Secret, if decryption and all validations pass
 */
export declare function decryptSecretFromMetadata(metadata: unknown, [secrethash, amount, paymentId]: readonly [Hash, UInt<32>, UInt<8>?], signer: Signer): Secret | undefined;
/**
 * @param addressMetadata - metadata's address_metadata mapping
 * @param address - Address to search and validate
 * @returns AddressMetadata of given address
 */
export declare function searchValidMetadata(addressMetadata: RouteMetadata['address_metadata'], address: Address): matrixPresence.success | undefined;
/**
 * @param metadata - Transfer metadata to search on
 * @param address - Address metadata to search for
 * @returns Via object or undefined
 */
export declare function searchValidViaAddress(metadata: unknown | undefined, address: Address | undefined): Via | undefined;