import { utils } from "ethers";
import { Segment } from './segment';
import { Address, RLPTx, RLPItem, Hash } from './helpers/types';
import BigNumber = utils.BigNumber;
export declare class DecoderUtility {
    static decode(bytes: string): string[];
    static getAddress(addressString: string): string;
}
/**
 * BaseTransaction is raw transaction data structure
 * @title BaseTransaction
 * @descriotion abstract class of Transaction
 */
export declare abstract class BaseTransaction {
    label: BigNumber;
    maxBlock: BigNumber;
    items: RLPTx;
    /**
     * BaseTransaction
     * @param label is transaction type
     * @param items is transaction body
     */
    constructor(label: number, items: RLPTx);
    withMaxBlkNum(maxBlock: number): this;
    encode(): string;
    hash(): string;
    serialize(): string;
    abstract getInput(index: number): TransactionOutput;
    abstract getInputs(): TransactionOutput[];
    abstract getOutput(index: number): TransactionOutput;
    abstract getOutputs(): TransactionOutput[];
    abstract getSegments(): Segment[];
    /**
     * @description verify function verify transaction's segment, owner and signatures.
     * @param signatures
     */
    abstract verify(signatures: string[], hash: string): boolean;
    abstract normalizeSigs(signatures: string[], hash?: string): string[];
    abstract requireConfsig(): boolean;
}
/**
 * @title TransactionDecoder
 * @description The decoder for transaction
 */
export declare class TransactionDecoder {
    /**
     * decode
     * @param bytes is hex string
     */
    static decode(bytes: string): BaseTransaction;
}
export declare class TransactionOutputDeserializer {
    static deserialize(data: any[]): TransactionOutput;
}
export declare abstract class TransactionOutput {
    abstract getLabel(): Hash;
    abstract withBlkNum(blkNum: BigNumber): TransactionOutput;
    abstract getOwners(): Address[];
    abstract getBlkNum(): BigNumber;
    abstract getSegment(index: number): Segment;
    abstract hash(): Hash;
    abstract getBytes(): string;
    abstract serialize(): any;
    /**
     * @description checkSpend function verify that the transaction spend UTXO correctly.
     * @param txo
     */
    abstract isSpent(txo: TransactionOutput): boolean;
    getRemainingState(txo: TransactionOutput): TransactionOutput[];
    abstract toObject(): any;
}
export declare class OwnState extends TransactionOutput {
    segment: Segment;
    owner: Address;
    blkNum: BigNumber | null;
    constructor(segment: Segment, owner: Address);
    static setAddress(_OwnStateAddress: Address): void;
    getLabel(): Hash;
    withBlkNum(blkNum: BigNumber): this;
    setBlkNum(blkNum: BigNumber): void;
    getBlkNum(): utils.BigNumber;
    getOwners(): string[];
    getSegment(index: number): Segment;
    serialize(): (string | string[])[];
    static deserialize(data: any[]): OwnState;
    getBytes(): string;
    hash(): Hash;
    /**
     * @description verify txo spend this instance correctly
     */
    isSpent(txo: TransactionOutput): boolean;
    private joinHex;
    toObject(): {
        start: string;
        end: string;
        owner: string[];
        blkNum: string;
    };
}
export declare class DepositTransaction extends BaseTransaction {
    depositor: Address;
    segment: Segment;
    constructor(depositor: Address, segment: Segment);
    static fromTuple(tuple: RLPItem[]): DepositTransaction;
    static deserialize(bytes: string): DepositTransaction;
    getInput(): TransactionOutput;
    getInputs(): TransactionOutput[];
    getOutput(): TransactionOutput;
    getOutputs(): TransactionOutput[];
    getSegments(): Segment[];
    verify(signatures: string[], hash: string): boolean;
    normalizeSigs(signatures: string[], hash?: string): string[];
    requireConfsig(): boolean;
}
export declare class SplitTransaction extends BaseTransaction {
    from: Address;
    segment: Segment;
    blkNum: BigNumber;
    to: Address;
    constructor(from: Address, segment: Segment, blkNum: BigNumber, to: Address);
    static Transfer(from: Address, segment: Segment, blkNum: BigNumber, to: Address): SplitTransaction;
    static fromTuple(tuple: RLPItem[]): SplitTransaction;
    static decode(bytes: string): SplitTransaction;
    getInput(): TransactionOutput;
    getInputs(): TransactionOutput[];
    getOutput(index: number): TransactionOutput;
    getOutputs(): OwnState[];
    getSegments(): Segment[];
    /**
     * @description verify transfer transaction
     *     see also https://github.com/cryptoeconomicslab/chamber-packages/blob/master/packages/chamber-contracts/contracts/verifier/StandardVerifier.vy#L92
     * @param signatures
     */
    verify(signatures: string[], hash: string): boolean;
    normalizeSigs(signatures: string[], hash?: string): string[];
    requireConfsig(): boolean;
}
export declare class MergeTransaction extends BaseTransaction {
    from: Address;
    segment1: Segment;
    segment2: Segment;
    blkNum1: BigNumber;
    blkNum2: BigNumber;
    to: Address;
    constructor(from: Address, segment1: Segment, segment2: Segment, to: Address, blkNum1: BigNumber, blkNum2: BigNumber);
    static fromTuple(tuple: RLPItem[]): MergeTransaction;
    static decode(bytes: string): MergeTransaction;
    getInput(index: number): TransactionOutput;
    getInputs(): TransactionOutput[];
    getOutput(): TransactionOutput;
    getOutputs(): TransactionOutput[];
    getSegments(): Segment[];
    /**
     * @description verify transaction
     *     see also https://github.com/cryptoeconomicslab/chamber-packages/blob/master/packages/chamber-contracts/contracts/verifier/StandardVerifier.vy#L154
     * @param signatures
     */
    verify(signatures: string[], hash: string): boolean;
    normalizeSigs(signatures: string[], hash?: string): string[];
    requireConfsig(): boolean;
}
export declare class SwapTransaction extends BaseTransaction {
    from1: Address;
    from2: Address;
    segment1: Segment;
    segment2: Segment;
    blkNum1: BigNumber;
    blkNum2: BigNumber;
    constructor(from1: Address, segment1: Segment, blkNum1: BigNumber, from2: Address, segment2: Segment, blkNum2: BigNumber);
    static SimpleSwap(from1: Address, segment1: Segment, blkNum1: BigNumber, from2: Address, segment2: Segment, blkNum2: BigNumber): SwapTransaction;
    static fromTuple(tuple: RLPItem[]): SwapTransaction;
    static decode(bytes: string): SwapTransaction;
    getInput(index: number): TransactionOutput;
    getInputs(): TransactionOutput[];
    getInputByOwner(owner: Address): TransactionOutput | null;
    getOutput(index: number): TransactionOutput;
    getOutputs(): OwnState[];
    getSegments(): Segment[];
    /**
     * @description verify swap transaction
     *     see also https://github.com/cryptoeconomicslab/chamber-packages/blob/master/packages/chamber-contracts/contracts/verifier/MultisigVerifier.vy#L86
     * @param signatures
     */
    verify(signatures: string[], hash: string): boolean;
    normalizeSigs(signatures: string[], hash?: string): string[];
    requireConfsig(): boolean;
}