@radixdlt/atom-transaction-mapping/dist/fromAtom/_types.d.ts

Create Atoms from actions

import { AnyUpParticle, TokenBase, TokenDefinitionBase } from '@radixdlt/atom';
import { AtomT, ResourceIdentifierT } from '@radixdlt/atom/src/_types';
import { AddressT } from '@radixdlt/account';
import { AmountT } from '@radixdlt/primitives';
import { Result } from 'neverthrow';
import { Observable } from 'rxjs';
export declare type TokenDefinition = TokenDefinitionBase & Readonly<{
    supply?: AmountT;
}>;
export declare type TokenAmount = Readonly<{
    amount: AmountT;
    token: TokenBase | TokenDefinition;
}>;
export declare enum ExecutedUserActionType {
    TOKEN_TRANSFER = "TokenTransfer"
}
export declare type ExecutedUserAction = Readonly<{
    executedUserActionType: ExecutedUserActionType;
}>;
export declare type TokenTransfer = ExecutedUserAction & Readonly<{
    from: AddressT;
    to: AddressT;
    tokenAmount: TokenAmount;
}>;
export declare type TokenBalance = Readonly<{
    owner: AddressT;
    tokenAmount: TokenAmount;
}>;
export declare enum ApplicationStateType {
    TOKEN_BALANCES_FOR_ONE_ACCOUNT = "TokenBalancesForOneAccount",
    TOKEN_BALANCES_PER_ACCOUNT = "TokenBalancesPerAccount"
}
export declare type ApplicationState = Readonly<{
    stateType: ApplicationStateType;
}>;
export declare type TokenBalancesForOneAccount = ApplicationState & Readonly<{
    balances: Map<ResourceIdentifierT, TokenBalance>;
    owner: AddressT;
    size: number;
    balanceOf: (resourceIdentifier: ResourceIdentifierT) => TokenBalance | undefined;
}>;
export declare type TokenBalancesPerAccount = ApplicationState & Readonly<{
    balances: Map<AddressT, TokenBalancesForOneAccount>;
    size: number;
    balancesFor: (owner: AddressT) => TokenBalancesForOneAccount;
}>;
export declare type ParticleReducer<S extends ApplicationState> = Readonly<{
    applicationStateType: ApplicationStateType;
    initialState: S;
    reduce: (input: Readonly<{
        state: S;
        upParticle: AnyUpParticle;
    }>) => Result<S, Error>;
    combine: (input: Readonly<{
        current: S;
        newState: S;
    }>) => Result<S, Error>;
    reduceFromInitialState: (upParticles: AnyUpParticle[]) => Result<S, Error>;
}>;
export declare type TokenBalancesForOneAccountReducer = ParticleReducer<TokenBalancesForOneAccount> & Readonly<{
    applicationStateType: ApplicationStateType.TOKEN_BALANCES_FOR_ONE_ACCOUNT;
}>;
export declare type TokenBalancesPerAccountReducer = ParticleReducer<TokenBalancesPerAccount> & Readonly<{
    applicationStateType: ApplicationStateType.TOKEN_BALANCES_PER_ACCOUNT;
}>;
export declare type AtomToActionMapperInput = Readonly<{
    atom: AtomT;
    addressOfActiveAccount: AddressT;
}>;
export declare type AtomToExecutedActionsMapper<A extends ExecutedUserAction> = Readonly<{
    executedUserActionType: ExecutedUserActionType;
    map: (input: AtomToActionMapperInput) => Observable<A>;
}>;
export declare type AtomToTokenTransfersMapper = AtomToExecutedActionsMapper<TokenTransfer>;
//# sourceMappingURL=_types.d.ts.map