Variable default

Type declaration

• anyoneCanPay: {
      CellCollector: CellCollectorConstructor;
      injectCapacity: ((cellCollector, txSkeleton, outputIndex, capacity, __namedParameters?) => Promise<TransactionSkeletonType>);
      prepareSigningEntries: ((txSkeleton, __namedParameters?) => TransactionSkeletonType);
      setupInputCell: ((txSkeleton, inputCell, _fromInfo?, __namedParameters?) => Promise<TransactionSkeletonType>);
      setupOutputCell: ((txSkeleton, outputCell, __namedParameters?) => Promise<TransactionSkeletonType>);
      withdraw: ((txSkeleton, fromInput, toAddress, capacity, __namedParameters?) => Promise<TransactionSkeletonType>);
  }

  • CellCollector: CellCollectorConstructor

  • injectCapacity: ((cellCollector, txSkeleton, outputIndex, capacity, __namedParameters?) => Promise<TransactionSkeletonType>)

    • • (cellCollector, txSkeleton, outputIndex, capacity, __namedParameters?): Promise<TransactionSkeletonType>

      • Parameters

        • cellCollector: CellCollectorType

        • txSkeleton: TransactionSkeletonType

        • outputIndex: number

        • capacity: BIish

        • __namedParameters: Options = {}

        Returns Promise<TransactionSkeletonType>

  • prepareSigningEntries: ((txSkeleton, __namedParameters?) => TransactionSkeletonType)

    • • (txSkeleton, __namedParameters?): TransactionSkeletonType

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • __namedParameters: Options = {}

        Returns TransactionSkeletonType

  • setupInputCell: ((txSkeleton, inputCell, _fromInfo?, __namedParameters?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, inputCell, _fromInfo?, __namedParameters?): Promise<TransactionSkeletonType>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • inputCell: Cell

        • Optional _fromInfo: FromInfo

        • __namedParameters: Options & {
              defaultWitness?: string;
              since?: string;
          } = {}

        Returns Promise<TransactionSkeletonType>

  • setupOutputCell: ((txSkeleton, outputCell, __namedParameters?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, outputCell, __namedParameters?): Promise<TransactionSkeletonType>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • outputCell: Cell

        • __namedParameters: Options = {}

        Returns Promise<TransactionSkeletonType>

  • withdraw: ((txSkeleton, fromInput, toAddress, capacity, __namedParameters?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, fromInput, toAddress, capacity, __namedParameters?): Promise<TransactionSkeletonType>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInput: Cell

        • toAddress: string

        • capacity: BIish

        • __namedParameters: Options = {}

        Returns Promise<TransactionSkeletonType>

• common: {
      __tests__: {
          _commonTransfer: ((txSkeleton, fromInfos, amount, minimalChangeCapacity, __namedParameters?) => Promise<{
              capacity: bigint;
              changeCapacity: bigint;
              txSkeleton: TransactionSkeletonType;
          }>);
          calculateFee: ((size, feeRate) => bigint);
          calculateFeeCompatible: ((size, feeRate) => BI);
          generateLockScriptInfos: ((__namedParameters?) => void);
          getLockScriptInfos: (() => LockScriptInfosType);
          getTransactionSize: ((txSkeleton) => number);
          getTransactionSizeByTx: ((tx) => number);
          resetLockScriptInfos: (() => void);
      };
      injectCapacity: ((txSkeleton, fromInfos, amount, changeAddress?, tipHeader?, __namedParameters?) => Promise<TransactionSkeletonType>);
      payFee: ((txSkeleton, fromInfos, amount, tipHeader?, __namedParameters?) => Promise<TransactionSkeletonType>);
      payFeeByFeeRate: ((txSkeleton, fromInfos, feeRate, tipHeader?, __namedParameters?) => Promise<TransactionSkeletonType>);
      prepareSigningEntries: ((txSkeleton, __namedParameters?) => TransactionSkeletonType);
      registerCustomLockScriptInfos: ((infos) => void);
      setupInputCell: ((txSkeleton, inputCell, fromInfo?, options?) => Promise<TransactionSkeletonType>);
      transfer: ((txSkeleton, fromInfos, toAddress, amount, changeAddress?, tipHeader?, options?) => Promise<TransactionSkeletonType>);
  }

  • __tests__: {
        _commonTransfer: ((txSkeleton, fromInfos, amount, minimalChangeCapacity, __namedParameters?) => Promise<{
            capacity: bigint;
            changeCapacity: bigint;
            txSkeleton: TransactionSkeletonType;
        }>);
        calculateFee: ((size, feeRate) => bigint);
        calculateFeeCompatible: ((size, feeRate) => BI);
        generateLockScriptInfos: ((__namedParameters?) => void);
        getLockScriptInfos: (() => LockScriptInfosType);
        getTransactionSize: ((txSkeleton) => number);
        getTransactionSizeByTx: ((tx) => number);
        resetLockScriptInfos: (() => void);
    }

    • _commonTransfer: ((txSkeleton, fromInfos, amount, minimalChangeCapacity, __namedParameters?) => Promise<{
          capacity: bigint;
          changeCapacity: bigint;
          txSkeleton: TransactionSkeletonType;
      }>)

      • • (txSkeleton, fromInfos, amount, minimalChangeCapacity, __namedParameters?): Promise<{
              capacity: bigint;
              changeCapacity: bigint;
              txSkeleton: TransactionSkeletonType;
          }>

        • Parameters

          • txSkeleton: TransactionSkeletonType

          • fromInfos: FromInfo[]

          • amount: bigint

          • minimalChangeCapacity: bigint

          • __namedParameters: Options & {
                enableDeductCapacity?: boolean;
            } = {}

          Returns Promise<{
              capacity: bigint;
              changeCapacity: bigint;
              txSkeleton: TransactionSkeletonType;
          }>

    • calculateFee: ((size, feeRate) => bigint)

      • • (size, feeRate): bigint

        • Parameters

          • size: number

          • feeRate: bigint

          Returns bigint

    • calculateFeeCompatible: ((size, feeRate) => BI)

      • • (size, feeRate): BI

        • Parameters

          • size: number

          • feeRate: BIish

          Returns BI

    • generateLockScriptInfos: ((__namedParameters?) => void)

      • • (__namedParameters?): void

        • Parameters

          • __namedParameters: Options = {}

          Returns void

    • getLockScriptInfos: (() => LockScriptInfosType)

      • • (): LockScriptInfosType

        • Returns LockScriptInfosType

    • getTransactionSize: ((txSkeleton) => number)

      • • (txSkeleton): number

        • Parameters

          • txSkeleton: TransactionSkeletonType

          Returns number

    • getTransactionSizeByTx: ((tx) => number)

      • • (tx): number

        • Parameters

          • tx: Transaction

          Returns number

    • resetLockScriptInfos: (() => void)

      • • (): void

        • Returns void

  • injectCapacity: ((txSkeleton, fromInfos, amount, changeAddress?, tipHeader?, __namedParameters?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, fromInfos, amount, changeAddress?, tipHeader?, __namedParameters?): Promise<TransactionSkeletonType>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfos: FromInfo[]

        • amount: BIish

        • Optional changeAddress: string

        • Optional tipHeader: Header

        • __namedParameters: {
              LocktimePoolCellCollector?: CellCollectorConstructor;
              config?: Config;
              enableDeductCapacity?: boolean;
              useLocktimeCellsFirst?: boolean;
          } = {}

          • Optional LocktimePoolCellCollector?: CellCollectorConstructor

          • Optional config?: Config

          • Optional enableDeductCapacity?: boolean

          • Optional useLocktimeCellsFirst?: boolean

        Returns Promise<TransactionSkeletonType>

  • payFee: ((txSkeleton, fromInfos, amount, tipHeader?, __namedParameters?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, fromInfos, amount, tipHeader?, __namedParameters?): Promise<TransactionSkeletonType>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfos: FromInfo[]

        • amount: BIish

        • Optional tipHeader: Header

        • __namedParameters: {
              config?: Config;
              enableDeductCapacity?: boolean;
              useLocktimeCellsFirst?: boolean;
          } = {}

          • Optional config?: Config

          • Optional enableDeductCapacity?: boolean

          • Optional useLocktimeCellsFirst?: boolean

        Returns Promise<TransactionSkeletonType>

  • payFeeByFeeRate: ((txSkeleton, fromInfos, feeRate, tipHeader?, __namedParameters?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, fromInfos, feeRate, tipHeader?, __namedParameters?): Promise<TransactionSkeletonType>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfos: FromInfo[]

        • feeRate: BIish

        • Optional tipHeader: Header

        • __namedParameters: {
              config?: Config;
              enableDeductCapacity?: boolean;
              useLocktimeCellsFirst?: boolean;
          } = {}

          • Optional config?: Config

          • Optional enableDeductCapacity?: boolean

          • Optional useLocktimeCellsFirst?: boolean

        Returns Promise<TransactionSkeletonType>

  • prepareSigningEntries: ((txSkeleton, __namedParameters?) => TransactionSkeletonType)

    • • (txSkeleton, __namedParameters?): TransactionSkeletonType

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • __namedParameters: Options = {}

        Returns TransactionSkeletonType

  • registerCustomLockScriptInfos: ((infos) => void)

    • • (infos): void

      • Registers LockScriptInfo for custom scripts.

        Parameters

        • infos: LockScriptInfo[]

        Returns void

  • setupInputCell: ((txSkeleton, inputCell, fromInfo?, options?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, inputCell, fromInfo?, options?): Promise<TransactionSkeletonType>

      • A function to transfer input to output, and add input & output to txSkeleton. And it will deal with cell deps and witnesses too. (Add the input required cell deps and witnesses.) It should be noted that the output must be added to the end of txSkeleton.get("outputs").

        Parameters

        • txSkeleton: TransactionSkeletonType

        • inputCell: Cell

        • Optional fromInfo: FromInfo

        • options: Options & {
              defaultWitness?: string;
              since?: string;
          } = {}

        Returns Promise<TransactionSkeletonType>

  • transfer: ((txSkeleton, fromInfos, toAddress, amount, changeAddress?, tipHeader?, options?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, fromInfos, toAddress, amount, changeAddress?, tipHeader?, options?): Promise<TransactionSkeletonType>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfos: FromInfo[]

        • toAddress: string

        • amount: BIish

        • Optional changeAddress: string

        • Optional tipHeader: Header

          will not use locktime cells if tipHeader not provided

        • options: {
              LocktimePoolCellCollector?: CellCollectorConstructor;
              config?: Config;
              useLocktimeCellsFirst?: boolean;
          } = {}

          • Optional LocktimePoolCellCollector?: CellCollectorConstructor

          • Optional config?: Config

          • Optional useLocktimeCellsFirst?: boolean

        Returns Promise<TransactionSkeletonType>

• dao: {
      CellCollector: typeof CellCollector;
      calculateDaoEarliestSince: ((depositBlockHeaderEpoch, withdrawBlockHeaderEpoch) => bigint);
      calculateDaoEarliestSinceCompatible: ((depositBlockHeaderEpoch, withdrawBlockHeaderEpoch) => BI);
      calculateMaximumWithdraw: ((withdrawCell, depositDao, withdrawDao) => bigint);
      calculateMaximumWithdrawCompatible: ((withdrawCell, depositDao, withdrawDao) => BI);
      deposit: ((txSkeleton, fromInfo, toAddress, amount, options?) => Promise<TransactionSkeletonType>);
      listDaoCells: ((cellProvider, fromAddress, cellType, options?) => AsyncIterator<Cell>);
      unlock: ((txSkeleton, depositInput, withdrawInput, toAddress, fromInfo, options?) => Promise<TransactionSkeletonType>);
      withdraw: ((txSkeleton, fromInput, fromInfo?, options?) => Promise<TransactionSkeletonType>);
  }

  • CellCollector: typeof CellCollector

  • calculateDaoEarliestSince: ((depositBlockHeaderEpoch, withdrawBlockHeaderEpoch) => bigint)

    • • (depositBlockHeaderEpoch, withdrawBlockHeaderEpoch): bigint

      • calculate a withdraw dao cell minimal unlock since

        Parameters

        • depositBlockHeaderEpoch: string

          depositBlockHeader.epoch

        • withdrawBlockHeaderEpoch: string

          withdrawBlockHeader.epoch

        Returns bigint

  • calculateDaoEarliestSinceCompatible: ((depositBlockHeaderEpoch, withdrawBlockHeaderEpoch) => BI)

    • • (depositBlockHeaderEpoch, withdrawBlockHeaderEpoch): BI

      • calculate a withdraw dao cell minimal unlock since

        Parameters

        • depositBlockHeaderEpoch: string

          depositBlockHeader.epoch

        • withdrawBlockHeaderEpoch: string

          withdrawBlockHeader.epoch

        Returns BI

  • calculateMaximumWithdraw: ((withdrawCell, depositDao, withdrawDao) => bigint)

    • • (withdrawCell, depositDao, withdrawDao): bigint

      • calculate maximum withdraw capacity when unlock

        Parameters

        • withdrawCell: Cell

          withdrawCell or depositCell

        • depositDao: string

          depositBlockHeader.dao

        • withdrawDao: string

          withdrawBlockHeader.dao

        Returns bigint

  • calculateMaximumWithdrawCompatible: ((withdrawCell, depositDao, withdrawDao) => BI)

    • • (withdrawCell, depositDao, withdrawDao): BI

      • calculate maximum withdraw capacity when unlock

        Parameters

        • withdrawCell: Cell

          withdrawCell or depositCell

        • depositDao: string

          depositBlockHeader.dao

        • withdrawDao: string

          withdrawBlockHeader.dao

        Returns BI

  • deposit: ((txSkeleton, fromInfo, toAddress, amount, options?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, fromInfo, toAddress, amount, options?): Promise<TransactionSkeletonType>

      • deposit a cell to DAO

        Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfo: FromInfo

        • toAddress: string

          deposit cell lock address

        • amount: BIish

          capacity in shannon

        • options: Options = {}

        Returns Promise<TransactionSkeletonType>

  • listDaoCells: ((cellProvider, fromAddress, cellType, options?) => AsyncIterator<Cell>)

    • • (cellProvider, fromAddress, cellType, options?): AsyncIterator<Cell>

      • list DAO cells,

        Parameters

        • cellProvider: CellProvider

        • fromAddress: string

        • cellType: "all" | "deposit" | "withdraw"

        • options: Options = {}

        Returns AsyncIterator<Cell>

  • unlock: ((txSkeleton, depositInput, withdrawInput, toAddress, fromInfo, options?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, depositInput, withdrawInput, toAddress, fromInfo, options?): Promise<TransactionSkeletonType>

      • Unlock a withdrew DAO cell

        Parameters

        • txSkeleton: TransactionSkeletonType

        • depositInput: Cell

          deposited DAO cell

        • withdrawInput: Cell

          withdrew DAO cell

        • toAddress: string

        • fromInfo: FromInfo

        • options: Options & {
              RpcClient?: typeof RPC;
          } = {}

        Returns Promise<TransactionSkeletonType>

  • withdraw: ((txSkeleton, fromInput, fromInfo?, options?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, fromInput, fromInfo?, options?): Promise<TransactionSkeletonType>

      • withdraw an deposited DAO cell

        Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInput: Cell

          deposited DAO cell

        • Optional fromInfo: FromInfo

        • options: Options = {}

        Returns Promise<TransactionSkeletonType>

• locktimePool: {
      CellCollector: CellCollectorConstructor;
      injectCapacity: ((txSkeleton, outputIndex, fromInfos, tipHeader, __namedParameters?) => Promise<TransactionSkeletonType>);
      injectCapacityWithoutChange: ((txSkeleton, fromInfos, amount, tipHeader, minimalChangeCapacity, __namedParameters) => Promise<{
          capacity: bigint;
          changeCapacity: bigint;
          txSkeleton: TransactionSkeletonType;
      }>);
      injectCapacityWithoutChangeCompatible: ((txSkeleton, fromInfos, amount, tipHeader, minimalChangeCapacity, __namedParameters) => Promise<{
          capacity: BI;
          changeCapacity: BI;
          txSkeleton: TransactionSkeletonType;
      }>);
      payFee: ((txSkeleton, fromInfos, amount, tipHeader, __namedParameters?) => Promise<TransactionSkeletonType>);
      prepareSigningEntries: ((txSkeleton, __namedParameters?) => TransactionSkeletonType);
      setupInputCell: ((txSkeleton, inputCell, fromInfo?, __namedParameters?) => Promise<TransactionSkeletonType>);
      transfer: {
          (txSkeleton, fromInfos, toAddress, amount, tipHeader, __namedParameters): Promise<TransactionSkeletonType>;
          (txSkeleton, fromInfos, toAddress, amount, tipHeader, __namedParameters): Promise<[TransactionSkeletonType, bigint]>;
      };
      transferCompatible: {
          (txSkeleton, fromInfos, toAddress, amount, tipHeader, __namedParameters): Promise<TransactionSkeletonType>;
          (txSkeleton, fromInfos, toAddress, amount, tipHeader, __namedParameters): Promise<[TransactionSkeletonType, BI]>;
      };
  }

  • CellCollector: CellCollectorConstructor

  • injectCapacity: ((txSkeleton, outputIndex, fromInfos, tipHeader, __namedParameters?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, outputIndex, fromInfos, tipHeader, __namedParameters?): Promise<TransactionSkeletonType>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • outputIndex: number

        • fromInfos: FromInfo[]

        • tipHeader: Header

        • __namedParameters: Options & {
              LocktimeCellCollector?: CellCollectorConstructor;
              cellCollector?: ((...params) => AsyncIterable<LocktimeCell>);
          } = {}

        Returns Promise<TransactionSkeletonType>

  • injectCapacityWithoutChange: ((txSkeleton, fromInfos, amount, tipHeader, minimalChangeCapacity, __namedParameters) => Promise<{
        capacity: bigint;
        changeCapacity: bigint;
        txSkeleton: TransactionSkeletonType;
    }>)

    • • (txSkeleton, fromInfos, amount, tipHeader, minimalChangeCapacity, __namedParameters): Promise<{
            capacity: bigint;
            changeCapacity: bigint;
            txSkeleton: TransactionSkeletonType;
        }>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfos: FromInfo[]

        • amount: bigint

        • tipHeader: Header

        • minimalChangeCapacity: bigint

        • __namedParameters: {
              LocktimeCellCollector?: CellCollectorConstructor;
              config?: Config;
              enableDeductCapacity?: boolean;
          }

          • Optional LocktimeCellCollector?: CellCollectorConstructor

          • Optional config?: Config

          • Optional enableDeductCapacity?: boolean

        Returns Promise<{
            capacity: bigint;
            changeCapacity: bigint;
            txSkeleton: TransactionSkeletonType;
        }>

  • injectCapacityWithoutChangeCompatible: ((txSkeleton, fromInfos, amount, tipHeader, minimalChangeCapacity, __namedParameters) => Promise<{
        capacity: BI;
        changeCapacity: BI;
        txSkeleton: TransactionSkeletonType;
    }>)

    • • (txSkeleton, fromInfos, amount, tipHeader, minimalChangeCapacity, __namedParameters): Promise<{
            capacity: BI;
            changeCapacity: BI;
            txSkeleton: TransactionSkeletonType;
        }>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfos: FromInfo[]

        • amount: BIish

        • tipHeader: Header

        • minimalChangeCapacity: BIish

        • __namedParameters: {
              LocktimeCellCollector?: CellCollectorConstructor;
              config?: Config;
              enableDeductCapacity?: boolean;
          }

          • Optional LocktimeCellCollector?: CellCollectorConstructor

          • Optional config?: Config

          • Optional enableDeductCapacity?: boolean

        Returns Promise<{
            capacity: BI;
            changeCapacity: BI;
            txSkeleton: TransactionSkeletonType;
        }>

  • payFee: ((txSkeleton, fromInfos, amount, tipHeader, __namedParameters?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, fromInfos, amount, tipHeader, __namedParameters?): Promise<TransactionSkeletonType>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfos: FromInfo[]

        • amount: BIish

        • tipHeader: Header

        • __namedParameters: {
              LocktimeCellCollector?: CellCollectorConstructor;
              config?: Config;
          } = {}

          • Optional LocktimeCellCollector?: CellCollectorConstructor

          • Optional config?: Config

        Returns Promise<TransactionSkeletonType>

  • prepareSigningEntries: ((txSkeleton, __namedParameters?) => TransactionSkeletonType)

    • • (txSkeleton, __namedParameters?): TransactionSkeletonType

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • __namedParameters: Options = {}

        Returns TransactionSkeletonType

  • setupInputCell: ((txSkeleton, inputCell, fromInfo?, __namedParameters?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, inputCell, fromInfo?, __namedParameters?): Promise<TransactionSkeletonType>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • inputCell: Cell

        • Optional fromInfo: FromInfo

        • __namedParameters: Options & {
              defaultWitness?: string;
              since?: string;
          } = {}

        Returns Promise<TransactionSkeletonType>

  • transfer: {
        (txSkeleton, fromInfos, toAddress, amount, tipHeader, __namedParameters): Promise<TransactionSkeletonType>;
        (txSkeleton, fromInfos, toAddress, amount, tipHeader, __namedParameters): Promise<[TransactionSkeletonType, bigint]>;
    }

    • • (txSkeleton, fromInfos, toAddress, amount, tipHeader, __namedParameters): Promise<TransactionSkeletonType>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfos: FromInfo[]

        • toAddress: undefined | string

        • amount: bigint

        • tipHeader: Header

        • __namedParameters: {
              LocktimeCellCollector?: CellCollectorConstructor;
              assertAmountEnough?: true;
              config?: Config;
              requireToAddress?: boolean;
          }

          • Optional LocktimeCellCollector?: CellCollectorConstructor

          • Optional assertAmountEnough?: true

          • Optional config?: Config

          • Optional requireToAddress?: boolean

        Returns Promise<TransactionSkeletonType>

      • (txSkeleton, fromInfos, toAddress, amount, tipHeader, __namedParameters): Promise<[TransactionSkeletonType, bigint]>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfos: FromInfo[]

        • toAddress: undefined | string

        • amount: bigint

        • tipHeader: Header

        • __namedParameters: {
              LocktimeCellCollector?: CellCollectorConstructor;
              assertAmountEnough: false;
              config?: Config;
              requireToAddress?: boolean;
          }

          • Optional LocktimeCellCollector?: CellCollectorConstructor

          • assertAmountEnough: false

          • Optional config?: Config

          • Optional requireToAddress?: boolean

        Returns Promise<[TransactionSkeletonType, bigint]>

  • transferCompatible: {
        (txSkeleton, fromInfos, toAddress, amount, tipHeader, __namedParameters): Promise<TransactionSkeletonType>;
        (txSkeleton, fromInfos, toAddress, amount, tipHeader, __namedParameters): Promise<[TransactionSkeletonType, BI]>;
    }

    • • (txSkeleton, fromInfos, toAddress, amount, tipHeader, __namedParameters): Promise<TransactionSkeletonType>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfos: FromInfo[]

        • toAddress: undefined | string

        • amount: BIish

        • tipHeader: Header

        • __namedParameters: {
              LocktimeCellCollector?: CellCollectorConstructor;
              assertAmountEnough?: true;
              config?: Config;
              requireToAddress?: boolean;
          }

          • Optional LocktimeCellCollector?: CellCollectorConstructor

          • Optional assertAmountEnough?: true

          • Optional config?: Config

          • Optional requireToAddress?: boolean

        Returns Promise<TransactionSkeletonType>

      • (txSkeleton, fromInfos, toAddress, amount, tipHeader, __namedParameters): Promise<[TransactionSkeletonType, BI]>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfos: FromInfo[]

        • toAddress: undefined | string

        • amount: BIish

        • tipHeader: Header

        • __namedParameters: {
              LocktimeCellCollector?: CellCollectorConstructor;
              assertAmountEnough: false;
              config?: Config;
              requireToAddress?: boolean;
          }

          • Optional LocktimeCellCollector?: CellCollectorConstructor

          • assertAmountEnough: false

          • Optional config?: Config

          • Optional requireToAddress?: boolean

        Returns Promise<[TransactionSkeletonType, BI]>

• secp256k1Blake160: {
      CellCollector: CellCollectorConstructor;
      injectCapacity: ((txSkeleton, outputIndex, fromAddress, options?) => Promise<TransactionSkeletonType>);
      payFee: ((txSkeleton, fromAddress, amount, options?) => Promise<TransactionSkeletonType>);
      prepareSigningEntries: ((txSkeleton, options?) => TransactionSkeletonType);
      setupInputCell: ((txSkeleton, inputCell, _fromInfo?, options?) => Promise<TransactionSkeletonType>);
      transfer: {
          (txSkeleton, fromAddress, toAddress, amount, options?): Promise<TransactionSkeletonType>;
          (txSkeleton, fromAddress, toAddress, amount, options): Promise<[TransactionSkeletonType, bigint]>;
      };
      transferCompatible: {
          (txSkeleton, fromAddress, toAddress, amount, options?): Promise<TransactionSkeletonType>;
          (txSkeleton, fromAddress, toAddress, amount, options): Promise<[TransactionSkeletonType, BI]>;
      };
  }

  • CellCollector: CellCollectorConstructor

  • injectCapacity: ((txSkeleton, outputIndex, fromAddress, options?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, outputIndex, fromAddress, options?): Promise<TransactionSkeletonType>

      • Inject capacity from fromAddress to target output.

        Parameters

        • txSkeleton: TransactionSkeletonType

        • outputIndex: number

        • fromAddress: string

        • options: Options = {}

        Returns Promise<TransactionSkeletonType>

  • payFee: ((txSkeleton, fromAddress, amount, options?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, fromAddress, amount, options?): Promise<TransactionSkeletonType>

      • pay fee by secp256k1_blake160 script cells

        Parameters

        • txSkeleton: TransactionSkeletonType

        • fromAddress: string

        • amount: BIish

          fee in shannon

        • options: Options = {}

        Returns Promise<TransactionSkeletonType>

  • prepareSigningEntries: ((txSkeleton, options?) => TransactionSkeletonType)

    • • (txSkeleton, options?): TransactionSkeletonType

      • prepare for txSkeleton signingEntries, will update txSkeleton.get("signingEntries")

        Parameters

        • txSkeleton: TransactionSkeletonType

        • options: Options = {}

        Returns TransactionSkeletonType

  • setupInputCell: ((txSkeleton, inputCell, _fromInfo?, options?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, inputCell, _fromInfo?, options?): Promise<TransactionSkeletonType>

      • Setup input cell infos, such as cell deps and witnesses.

        Parameters

        • txSkeleton: TransactionSkeletonType

        • inputCell: Cell

        • Optional _fromInfo: FromInfo

        • options: Options & {
              defaultWitness?: string;
              since?: string;
          } = {}

        Returns Promise<TransactionSkeletonType>

  • transfer: {
        (txSkeleton, fromAddress, toAddress, amount, options?): Promise<TransactionSkeletonType>;
        (txSkeleton, fromAddress, toAddress, amount, options): Promise<[TransactionSkeletonType, bigint]>;
    }

    • • (txSkeleton, fromAddress, toAddress, amount, options?): Promise<TransactionSkeletonType>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromAddress: string

        • toAddress: undefined | null | string

        • amount: bigint

        • Optional options: {
              assertAmountEnough?: true;
              config?: Config;
              requireToAddress?: boolean;
          }

          • Optional assertAmountEnough?: true

          • Optional config?: Config

          • Optional requireToAddress?: boolean

        Returns Promise<TransactionSkeletonType>

      • (txSkeleton, fromAddress, toAddress, amount, options): Promise<[TransactionSkeletonType, bigint]>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromAddress: string

        • toAddress: undefined | null | string

        • amount: bigint

        • options: {
              assertAmountEnough: false;
              config?: Config;
              requireToAddress?: boolean;
          }

          • assertAmountEnough: false

          • Optional config?: Config

          • Optional requireToAddress?: boolean

        Returns Promise<[TransactionSkeletonType, bigint]>

  • transferCompatible: {
        (txSkeleton, fromAddress, toAddress, amount, options?): Promise<TransactionSkeletonType>;
        (txSkeleton, fromAddress, toAddress, amount, options): Promise<[TransactionSkeletonType, BI]>;
    }

    • • (txSkeleton, fromAddress, toAddress, amount, options?): Promise<TransactionSkeletonType>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromAddress: string

        • toAddress: undefined | null | string

        • amount: BIish

        • Optional options: {
              assertAmountEnough?: true;
              config?: Config;
              requireToAddress?: boolean;
          }

          • Optional assertAmountEnough?: true

          • Optional config?: Config

          • Optional requireToAddress?: boolean

        Returns Promise<TransactionSkeletonType>

      • (txSkeleton, fromAddress, toAddress, amount, options): Promise<[TransactionSkeletonType, BI]>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromAddress: string

        • toAddress: undefined | null | string

        • amount: BIish

        • options: {
              assertAmountEnough: false;
              config?: Config;
              requireToAddress?: boolean;
          }

          • assertAmountEnough: false

          • Optional config?: Config

          • Optional requireToAddress?: boolean

        Returns Promise<[TransactionSkeletonType, BI]>

• secp256k1Blake160Multisig: {
      CellCollector: CellCollectorConstructor;
      injectCapacity: ((txSkeleton, outputIndex, fromInfo, options?) => Promise<TransactionSkeletonType>);
      multisigArgs: ((serializedMultisigScript, since?) => HexString);
      payFee: ((txSkeleton, fromInfo, amount, options?) => Promise<TransactionSkeletonType>);
      prepareSigningEntries: ((txSkeleton, options?) => TransactionSkeletonType);
      serializeMultisigScript: ((params) => HexString);
      setupInputCell: ((txSkeleton, inputCell, fromInfo?, options?) => Promise<TransactionSkeletonType>);
      transfer: {
          (txSkeleton, fromInfo, toAddress, amount, options?): Promise<TransactionSkeletonType>;
          (txSkeleton, fromInfo, toAddress, amount, options): Promise<[TransactionSkeletonType, bigint]>;
      };
      transferCompatible: {
          (txSkeleton, fromInfo, toAddress, amount, options?): Promise<TransactionSkeletonType>;
          (txSkeleton, fromInfo, toAddress, amount, options): Promise<[TransactionSkeletonType, BI]>;
      };
  }

  • CellCollector: CellCollectorConstructor

  • injectCapacity: ((txSkeleton, outputIndex, fromInfo, options?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, outputIndex, fromInfo, options?): Promise<TransactionSkeletonType>

      • Inject capacity from fromInfo to target output.

        Parameters

        • txSkeleton: TransactionSkeletonType

        • outputIndex: number

        • fromInfo: FromInfo

        • options: Options = {}

        Returns Promise<TransactionSkeletonType>

  • multisigArgs: ((serializedMultisigScript, since?) => HexString)

    • • (serializedMultisigScript, since?): HexString

      • Parameters

        • serializedMultisigScript: string

        • Optional since: string

        Returns HexString

        lock script args

  • payFee: ((txSkeleton, fromInfo, amount, options?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, fromInfo, amount, options?): Promise<TransactionSkeletonType>

      • pay fee by multisig script cells

        Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfo: FromInfo

        • amount: BIish

          fee in shannon

        • options: Options = {}

        Returns Promise<TransactionSkeletonType>

  • prepareSigningEntries: ((txSkeleton, options?) => TransactionSkeletonType)

    • • (txSkeleton, options?): TransactionSkeletonType

      • prepare for txSkeleton signingEntries, will update txSkeleton.get("signingEntries")

        Parameters

        • txSkeleton: TransactionSkeletonType

        • options: Options = {}

        Returns TransactionSkeletonType

  • serializeMultisigScript: ((params) => HexString)

    • • (params): HexString

      • Parameters

        • params: MultisigScript

          multisig script params

        Returns HexString

        serialized multisig script

  • setupInputCell: ((txSkeleton, inputCell, fromInfo?, options?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, inputCell, fromInfo?, options?): Promise<TransactionSkeletonType>

      • Setup input cell infos, such as cell deps and witnesses.

        Parameters

        • txSkeleton: TransactionSkeletonType

        • inputCell: Cell

        • Optional fromInfo: FromInfo

        • options: Options & {
              defaultWitness?: string;
              requireMultisigScript?: boolean;
              since?: string;
          } = {}

        Returns Promise<TransactionSkeletonType>

  • transfer: {
        (txSkeleton, fromInfo, toAddress, amount, options?): Promise<TransactionSkeletonType>;
        (txSkeleton, fromInfo, toAddress, amount, options): Promise<[TransactionSkeletonType, bigint]>;
    }

    • • (txSkeleton, fromInfo, toAddress, amount, options?): Promise<TransactionSkeletonType>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfo: FromInfo

        • toAddress: undefined | string

        • amount: bigint

        • Optional options: {
              assertAmountEnough?: true;
              config?: Config;
              requireToAddress?: boolean;
          }

          • Optional assertAmountEnough?: true

          • Optional config?: Config

          • Optional requireToAddress?: boolean

        Returns Promise<TransactionSkeletonType>

      • (txSkeleton, fromInfo, toAddress, amount, options): Promise<[TransactionSkeletonType, bigint]>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfo: FromInfo

        • toAddress: undefined | string

        • amount: bigint

        • options: {
              assertAmountEnough: false;
              config?: Config;
              requireToAddress?: boolean;
          }

          • assertAmountEnough: false

          • Optional config?: Config

          • Optional requireToAddress?: boolean

        Returns Promise<[TransactionSkeletonType, bigint]>

  • transferCompatible: {
        (txSkeleton, fromInfo, toAddress, amount, options?): Promise<TransactionSkeletonType>;
        (txSkeleton, fromInfo, toAddress, amount, options): Promise<[TransactionSkeletonType, BI]>;
    }

    • • (txSkeleton, fromInfo, toAddress, amount, options?): Promise<TransactionSkeletonType>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfo: FromInfo

        • toAddress: undefined | string

        • amount: BIish

        • Optional options: {
              assertAmountEnough?: true;
              config?: Config;
              requireToAddress?: boolean;
          }

          • Optional assertAmountEnough?: true

          • Optional config?: Config

          • Optional requireToAddress?: boolean

        Returns Promise<TransactionSkeletonType>

      • (txSkeleton, fromInfo, toAddress, amount, options): Promise<[TransactionSkeletonType, BI]>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfo: FromInfo

        • toAddress: undefined | string

        • amount: BIish

        • options: {
              assertAmountEnough: false;
              config?: Config;
              requireToAddress?: boolean;
          }

          • assertAmountEnough: false

          • Optional config?: Config

          • Optional requireToAddress?: boolean

        Returns Promise<[TransactionSkeletonType, BI]>

• sudt: {
      issueToken: ((txSkeleton, fromInfo, amount, capacity?, tipHeader?, options?) => Promise<TransactionSkeletonType>);
      ownerForSudt: ((fromInfo, options?) => Token);
      packAmount: ((amount) => HexString);
      transfer: ((txSkeleton, fromInfos, sudtToken, toAddress, amount, changeAddress?, capacity?, tipHeader?, options?) => Promise<TransactionSkeletonType>);
      unpackAmount: ((data) => BI);
  }

  • issueToken: ((txSkeleton, fromInfo, amount, capacity?, tipHeader?, options?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, fromInfo, amount, capacity?, tipHeader?, options?): Promise<TransactionSkeletonType>

      • Issue an sUDT cell

        Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfo: FromInfo

        • amount: BIish

        • Optional capacity: BIish

        • Optional tipHeader: Header

        • options: Options = {}

        Returns Promise<TransactionSkeletonType>

  • ownerForSudt: ((fromInfo, options?) => Token)

    • • (fromInfo, options?): Token

      • Compute sudt token by owner from info.

        Parameters

        • fromInfo: FromInfo

        • options: Options = {}

        Returns Token

  • packAmount: ((amount) => HexString)

    • • (amount): HexString

      • Parameters

        • amount: BIish

        Returns HexString

  • transfer: ((txSkeleton, fromInfos, sudtToken, toAddress, amount, changeAddress?, capacity?, tipHeader?, options?) => Promise<TransactionSkeletonType>)

    • • (txSkeleton, fromInfos, sudtToken, toAddress, amount, changeAddress?, capacity?, tipHeader?, options?): Promise<TransactionSkeletonType>

      • Parameters

        • txSkeleton: TransactionSkeletonType

        • fromInfos: FromInfo[]

        • sudtToken: string

        • toAddress: string

        • amount: BIish

        • Optional changeAddress: string

          if not provided, will use first fromInfo

        • Optional capacity: BIish

        • Optional tipHeader: Header

        • options: Options & {
              LocktimePoolCellCollector?: any;
              splitChangeCell?: boolean;
          } = {}

          When splitChangeCell = true && change amount > 0 && change capacity >= minimalCellCapacity(change cell with sudt) + minimalCellCapacity(change cell without sudt), change cell will split to two change cells, one with sudt and one without.

        Returns Promise<TransactionSkeletonType>

  • unpackAmount: ((data) => BI)

    • • (data): BI

      • Parameters

        • data: BytesLike

        Returns BI