nomis-sdk/dist/index.d.ts

SDK for scoring the wallet on Ton

import { SendTransactionRequest } from '@tonconnect/sdk';
import { Transaction, SenderArguments } from '@ton/ton';

type TokenBalance = {
    amount: number;
    price: number;
    lastPriceDateTime: string;
    confidence: number;
    totalAmountPrice: number;
    chainId: number | undefined;
    id: string;
    symbol: string;
    name: string;
    decimals: string;
    logoUri: string | null | undefined;
};
interface MintedChain {
    isTestnet: boolean;
    isEnabled: boolean;
    chainId: number;
    hexChainId: string | null;
    chainName: string;
}
interface MintData {
    calculationModel: number;
    chainId: number;
    deadline: number;
    metadataUrl: string;
    mintedChain: MintedChain;
    mintedScore: number;
    nonce: number;
    referralCode: string;
    referrerCode: string;
    signature: string;
}
interface TurnoverInterval {
    start: number;
    end: number;
    value: number;
}
interface Stats {
    averageTransactionTime: number;
    balanceChangeInLastMonth: number;
    balanceChangeInLastYear: number;
    firstInTransferAddress: string | null;
    firstTransactionDate: string;
    historicalMedianBalanceUSD: number;
    holdTokensBalanceUSD: number;
    lastMonthTransactions: number;
    lastYearTransactions: number;
    maxTransactionTime: number;
    minTransactionTime: number;
    nativeBalance: number;
    nativeBalanceUSD: number;
    nativeToken: string;
    nftHolding: number;
    nftTrading: number;
    nftWorth: number;
    noData: boolean;
    scoredAt: string;
    timeSinceTheLastTransaction: number;
    tokenBalances: TokenBalance[];
    tokensHolding: number;
    totalRejectedTransactions: number;
    totalTransactions: number;
    transactionsPerMonth: number;
    turnoverIntervals: TurnoverInterval[];
    walletAge: number;
    walletTurnover: number;
    walletTurnoverUSD: number;
    statsDescriptions: Record<string, {
        label: string;
        description: string;
        units: string;
    }>;
}
interface IScoreData {
    address: string;
    mintData: MintData;
    mintPrice: number;
    referralCode: string;
    referrerReward: number;
    referrerAddress: string | null;
    score: number;
    scoreType: number;
    stats: Stats;
    signature: string | null;
}
interface IGetScoreParams {
    address: string;
    referrerCode?: string | null | undefined;
}
interface ITonContractParams {
    address: string;
}
interface IToken {
    name: string;
    score: number;
    updated: number;
    tokenId: number;
    calculationModel: number;
    chainId: number;
    owner: string;
    realTokenId: string | null;
}
type IMintData = MintData & Pick<IScoreData, "referrerAddress" | "referrerReward" | "mintPrice">;
interface IGetScoreResult {
    scoreData: IScoreData | undefined | null;
    mintData: IMintData | undefined | null;
    token: IToken | undefined | null;
    isUpdate: boolean;
    scoreName: string;
}
interface ITransactionSender {
    sendTransaction(transaction: SendTransactionRequest, ...args: any[]): unknown;
    [key: string]: any;
}

declare const isScoreHolder: ({ address, }: ITonContractParams) => Promise<boolean>;

declare function getScoreData({ address, referrerCode, }: IGetScoreParams): Promise<IGetScoreResult>;

interface MintScoreResult {
    mintToken: (params: ITransactionSender & IMintData) => undefined;
    getNewTxHash: (lastTx: Transaction) => string;
    checkMintingTxStatus: (updated: number, mintScore: number) => boolean;
    getMintingTxParams: (params: IMintData) => Promise<SenderArguments>;
}
declare function mintScore({ address }: ITonContractParams): {
    mintToken: () => undefined;
    getNewTxHash: () => string;
    checkMintingTxStatus: () => boolean;
    getMintingTxParams: () => {
        new (executor: (resolve: (value: SenderArguments | PromiseLike<SenderArguments>) => void, reject: (reason?: any) => void) => void): Promise<SenderArguments>;
        all<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>;
        all<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;
        race<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
        race<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
        readonly prototype: Promise<any>;
        reject<T = never>(reason?: any): Promise<T>;
        resolve(): Promise<void>;
        resolve<T>(value: T): Promise<Awaited<T>>;
        resolve<T>(value: T | PromiseLike<T>): Promise<Awaited<T>>;
        allSettled<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }>;
        allSettled<T>(values: Iterable<T | PromiseLike<T>>): Promise<PromiseSettledResult<Awaited<T>>[]>;
        any<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
        any<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
        withResolvers<T>(): PromiseWithResolvers<T>;
        readonly [Symbol.species]: PromiseConstructor;
    };
} | {
    mintToken: (({ tonConnect, mintPrice, referrerReward, deadline, metadataUrl, mintedScore, signature, nonce, referrerAddress, }: {
        tonConnect: ITransactionSender;
    } & IMintData) => Promise<undefined | Transaction>) | (() => undefined);
    getNewTxHash: ((lastTx: Transaction) => Promise<string>) | (() => string);
    getMintingTxParams: (({ mintPrice, referrerReward, deadline, metadataUrl, mintedScore, signature, nonce, referrerAddress, }: IMintData) => Promise<SenderArguments>) | (() => {
        new (executor: (resolve: (value: SenderArguments | PromiseLike<SenderArguments>) => void, reject: (reason?: any) => void) => void): Promise<SenderArguments>;
        all<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>;
        all<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;
        race<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
        race<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
        readonly prototype: Promise<any>;
        reject<T = never>(reason?: any): Promise<T>;
        resolve(): Promise<void>;
        resolve<T>(value: T): Promise<Awaited<T>>;
        resolve<T>(value: T | PromiseLike<T>): Promise<Awaited<T>>;
        allSettled<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }>;
        allSettled<T>(values: Iterable<T | PromiseLike<T>>): Promise<PromiseSettledResult<Awaited<T>>[]>;
        any<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
        any<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
        withResolvers<T>(): PromiseWithResolvers<T>;
        readonly [Symbol.species]: PromiseConstructor;
    });
};

declare const getMintedToken: ({ address }: ITonContractParams) => Promise<IToken | undefined>;

export { type IGetScoreParams, type IGetScoreResult, type IMintData, type IScoreData, type IToken, type ITonContractParams, type ITransactionSender, type MintScoreResult, getMintedToken, getScoreData, isScoreHolder, mintScore };