meta-contract/dist/mcp02/index.d.ts

Meta Contract SDK

/// <reference types="node" />
import { Bytes } from '../scryptlib';
import * as mvc from '../mvc';
import { Api, API_NET, API_TARGET } from '..';
import * as BN from '../bn.js';
import * as ftProto from './contract-proto/token.proto';
import { FungibleTokenUnspent } from '../api';
import { Buffer } from 'buffer';
export declare const sighashType: number;
type ParamUtxo = {
    txId: string;
    outputIndex: number;
    satoshis: number;
    wif?: string;
    address?: string | mvc.Address;
};
type Mcp02Options = {
    network?: API_NET;
    apiTarget?: API_TARGET;
    apiHost?: string;
    purse?: string;
    feeb?: number;
    dustLimitFactor?: number;
    dustAmount?: number;
    debug?: boolean;
};
type TokenReceiver = {
    address: string;
    amount: string;
};
type ParamFtUtxo = {
    txId: string;
    outputIndex: number;
    tokenAddress: string;
    tokenAmount: string;
    wif?: string;
};
export declare class FtManager {
    private network;
    private _api;
    private zeroAddress;
    private purse;
    private feeb;
    private dustCalculator?;
    transferCheckCodeHashArray: Bytes[];
    unlockContractCodeHashArray: Bytes[];
    private debug;
    get api(): Api;
    get sensibleApi(): Api;
    constructor({ network, apiTarget, purse, feeb, apiHost, dustLimitFactor, dustAmount, debug, }: Mcp02Options);
    /**
     * Create a transaction for genesis
     * @param tokenName token name, limited to 20 bytes
     * @param tokenSymbol the token symbol, limited to 10 bytes
     * @param decimalNum the decimal number, range 0-255
     * @param utxos (Optional) specify mvc utxos
     * @param changeAddress (Optional) specify mvc changeAddress
     * @param opreturnData (Optional) append an opReturn output
     * @param genesisWif the private key of the token genesiser
     * @param noBroadcast (Optional) whether not to broadcast the transaction, the default is false
     * @returns
     */
    genesis({ version, tokenName, tokenSymbol, decimalNum, utxos: utxosInput, changeAddress, opreturnData, genesisWif, noBroadcast, }: {
        version?: number;
        tokenName: string;
        tokenSymbol: string;
        decimalNum: number;
        utxos?: any[];
        changeAddress?: string | mvc.Address;
        opreturnData?: any;
        genesisWif?: string;
        noBroadcast?: boolean;
    }): Promise<{
        txHex: string;
        txid: string;
        tx: mvc.Transaction;
        codehash: string;
        genesis: string;
        sensibleId: string;
    }>;
    issue(options: {
        genesis: string;
        codehash: string;
        sensibleId: string;
        genesisWif: string;
        receiverAddress: string | mvc.Address;
        tokenAmount: string | BN;
        allowIncreaseMints: boolean;
        utxos?: ParamUtxo[];
        changeAddress?: string | mvc.Address;
        opreturnData?: any;
        noBroadcast?: boolean;
    }): Promise<{
        txHex: string;
        txid: string;
        tx: mvc.Transaction;
    }>;
    mint({ version, sensibleId, genesisWif, receiverAddress, tokenAmount, allowIncreaseMints, utxos, changeAddress, opreturnData, noBroadcast, }: {
        version?: number;
        sensibleId: string;
        genesisWif: string;
        receiverAddress: string | mvc.Address;
        tokenAmount: string | BN;
        allowIncreaseMints?: boolean;
        utxos?: ParamUtxo[];
        changeAddress?: string | mvc.Address;
        opreturnData?: any;
        noBroadcast?: boolean;
    }): Promise<{
        txHex: string;
        txid: string;
        tx: mvc.Transaction;
    }>;
    private _mint;
    private _prepareMintUtxo;
    private _getMintUtxo;
    private _calMintEstimateFee;
    merge({ codehash, genesis, ownerWif, utxos, changeAddress, noBroadcast, opreturnData, }: {
        codehash: string;
        genesis: string;
        ownerWif?: string;
        utxos?: ParamUtxo[];
        changeAddress?: string | mvc.Address;
        noBroadcast?: boolean;
        opreturnData?: any;
    }): Promise<{
        tx: mvc.Transaction;
        txHex: string;
        txid: string;
        routeCheckTx: mvc.Transaction;
        routeCheckTxHex: string;
    }>;
    totalMerge({ codehash, genesis, ownerWif, changeAddress, opreturnData, }: {
        codehash: string;
        genesis: string;
        ownerWif?: string;
        changeAddress?: string | mvc.Address;
        opreturnData?: any;
    }): Promise<{
        txids: string[];
    }>;
    private _pretreatUtxos;
    /**
     * Estimate the cost of genesis
     * @param opreturnData
     * @param utxoMaxCount Maximum number of MVC UTXOs supported
     * @returns
     */
    getGenesisEstimateFee({ opreturnData, utxoMaxCount, }: {
        opreturnData?: any;
        utxoMaxCount?: number;
    }): Promise<number>;
    private _genesis;
    transfer({ codehash, genesis, receivers, senderWif, ftUtxos, ftChangeAddress, utxos, changeAddress, middleChangeAddress, middlePrivateKey, minUtxoSet, isMerge, opreturnData, noBroadcast, }: {
        codehash: string;
        genesis: string;
        receivers?: TokenReceiver[];
        senderWif?: string;
        ftUtxos?: ParamFtUtxo[];
        ftChangeAddress?: string | mvc.Address;
        utxos?: ParamUtxo[];
        changeAddress?: string | mvc.Address;
        middleChangeAddress?: string | mvc.Address;
        middlePrivateKey?: string | mvc.PrivateKey;
        minUtxoSet?: boolean;
        isMerge?: boolean;
        opreturnData?: any;
        noBroadcast?: boolean;
    }): Promise<{
        tx: mvc.Transaction;
        txHex: string;
        txid: string;
        routeCheckTx: mvc.Transaction;
        routeCheckTxHex: string;
    }>;
    /**
     * burn token
     * @param codehash token codehash
     * @param genesis token genesis
     * @param ftUtxos ft utxos to burn, must be sent to zero address
     * @param utxos fee provider utxos
     * @param utxoPrivateKey fee provider utxo private key
     * @param changeAddress satoshi change address
     * @param opreturnData opreturn data
     * @param noBroadcast if true, will not broadcast tx
     */
    burn({ codehash, genesis, ftUtxos, utxos, utxoPrivateKey, changeAddress, opreturnData, noBroadcast, }: {
        codehash: string;
        genesis: string;
        ftUtxos?: ParamFtUtxo[];
        utxos?: ParamUtxo[];
        utxoPrivateKey?: string | mvc.PrivateKey;
        changeAddress?: string | mvc.Address;
        opreturnData?: any;
        noBroadcast?: boolean;
    }): Promise<{
        tx: mvc.Transaction;
        txHex: string;
        txid: string;
        routeCheckTx: mvc.Transaction;
        routeCheckTxHex: string;
    }>;
    private _pretreatFtUtxos;
    /**
     * prepare transfer tokens, decide which transfer pattern to use, preprocess ft utxos(fetch previous transactions for tx building)
     * @param codehash codehash of token
     * @param genesis genesis of token
     * @param receivers token receivers, will be ignored if isMerge is true
     * @param ftUtxos input ft utxos
     * @param ftChangeAddress change address of ft
     * @param isMerge merge utxos, if true, all the token will be merged into one utxo and send to the change address
     * @param minUtxoSet if true, will use minimum utxo set as possible
     * @private
     */
    private _prepareTransferTokens;
    /**
     * prepare burn tokens,preprocess ft utxos(fetch previous transactions for tx building)
     * @param codehash codehash of token
     * @param genesis genesis of token
     * @param ftUtxos input ft utxos
     * @private
     */
    private _prepareBurnTokens;
    /**
     * Fetch previous transactions for each ft utxo
     * @param ftUtxos ft utxos
     * @param genesis genesis of token
     * @private
     */
    private perfectFtUtxosInfo;
    /**
     * composite a token transfer transaction and amount check transaction
     * @param codehash codehash of the token
     * @param genesis genesis of the token
     * @param receivers token receivers
     * @param ftUtxos input ftUtxos
     * @param ftPrivateKeys private keys of ftUtxos
     * @param ftChangeAddress change address of ftUtxos
     * @param utxos utxos for paying fee
     * @param utxoPrivateKeys private keys of utxos(fee paying)
     * @param changeAddress change address of utxos(fee paying)
     * @param middlePrivateKey
     * @param middleChangeAddress
     * @param isMerge whether to merge the token utxos
     * @param opreturnData opreturn data to be added to the transaction
     * @param minUtxoSet
     * @private
     */
    private _transfer;
    /**
     * burn the provided ft utxos, the utxo must be sent to the zero address in order to burn
     * @param codehash codehash of the token
     * @param genesis genesis of the token
     * @param ftUtxos ft utxos to burn(must be transferred to the zero address)
     * @param utxos utxos to pay the fee
     * @param utxoPrivateKey private keys of the utxos(fee paying utxos)
     * @param changeAddress the address to receive the change satoshis
     * @param opreturnData opreturn data
     * @private
     * @returns {Promise<{transferCheckTxComposer: TxComposer, txComposer: TxComposer}>}
     */
    private _burn;
    /**
     * calculate transfer fee for ft transfer
     * @param p2pkhInputNum
     * @param tokenInputArray
     * @param tokenOutputArray
     * @param tokenTransferType
     * @param opreturnData
     * @private
     */
    private _calTransferEstimateFee;
    /**
     * calculate transfer fee for ft burn
     * this includes the fee for transfer check tx
     * @param p2pkhInputNum
     * @param tokenInputArray
     * @param opreturnData
     * @param tokenUnlockType
     * @private
     */
    private _calBurnEstimateFee;
    private getDustThreshold;
    getBalance({ codehash, genesis, address, }: {
        codehash: string;
        genesis: string;
        address: string;
    }): Promise<string>;
    /**
     * Query token balance detail
     * @param codehash
     * @param genesis
     * @param address
     * @returns
     */
    getBalanceDetail({ codehash, genesis, address, }: {
        codehash: string;
        genesis: string;
        address: string;
    }): Promise<{
        balance: string;
        pendingBalance: string;
        utxoCount: number;
        decimal: number;
    }>;
    /**
     * Query the Token list under this address. Get the balance of each token
     * @param address
     * @returns
     */
    getSummary(address: string): Promise<import("../api").FungibleTokenSummary[]>;
    getFtUtxos(codehash: string, genesis: string, address: string, count?: number): Promise<FungibleTokenUnspent[]>;
    getMergeEstimateFee({ codehash, genesis, ownerWif, ownerPublicKey, ftUtxos, ftChangeAddress, opreturnData, utxoMaxCount, minUtxoSet, }: {
        codehash: string;
        genesis: string;
        ownerWif?: string;
        ownerPublicKey?: string | mvc.PublicKey;
        ftUtxos?: ParamFtUtxo[];
        ftChangeAddress?: string | mvc.Address;
        opreturnData?: any;
        utxoMaxCount?: number;
        minUtxoSet?: boolean;
    }): Promise<number>;
    getTransferEstimateFee({ codehash, genesis, receivers, senderWif, senderPrivateKey, senderPublicKey, ftUtxos, ftChangeAddress, isMerge, opreturnData, utxoMaxCount, minUtxoSet, }: {
        codehash: string;
        genesis: string;
        receivers?: TokenReceiver[];
        senderWif?: string;
        senderPrivateKey?: string | mvc.PrivateKey;
        senderPublicKey?: string | mvc.PublicKey;
        ftUtxos?: ParamFtUtxo[];
        ftChangeAddress?: string | mvc.Address;
        isMerge?: boolean;
        opreturnData?: any;
        utxoMaxCount?: number;
        minUtxoSet?: boolean;
    }): Promise<number>;
    static parseTokenScript(scriptBuf: Buffer, network?: API_NET): {
        codehash: string;
        genesis: string;
        sensibleId: string;
        tokenName: string;
        tokenSymbol: string;
        decimalNum: number;
        tokenAddress: string;
        tokenAmount: any;
        genesisHash: string;
        sensibleID: ftProto.SensibleID;
        protoVersion: number;
        protoType: number;
    };
}
export {};