caver-js/types/test/transaction-test.ts

caver-js is a JavaScript API library that allows developers to interact with a Kaia node

/*
    Copyright 2021 The caver-js Authors
    This file is part of the caver-js library.
    The caver-js library is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    The caver-js library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Lesser General Public License for more details.
    You should have received a copy of the GNU Lesser General Public License
    along with the caver-js. If not, see <http://www.gnu.org/licenses/>.
*/

import Caver, {
    LegacyTransaction,
    ValueTransfer,
    FeeDelegatedValueTransfer,
    FeeDelegatedValueTransferWithRatio,
    ValueTransferMemo,
    FeeDelegatedValueTransferMemo,
    FeeDelegatedValueTransferMemoWithRatio,
    AccountUpdate,
    FeeDelegatedAccountUpdate,
    FeeDelegatedAccountUpdateWithRatio,
    SmartContractDeploy,
    FeeDelegatedSmartContractDeploy,
    FeeDelegatedSmartContractDeployWithRatio,
    SmartContractExecution,
    FeeDelegatedSmartContractExecution,
    FeeDelegatedSmartContractExecutionWithRatio,
    Cancel,
    FeeDelegatedCancel,
    FeeDelegatedCancelWithRatio,
    ChainDataAnchoring,
    FeeDelegatedChainDataAnchoring,
    FeeDelegatedChainDataAnchoringWithRatio,
    SingleKeyring,
    MultipleKeyring,
    RoleBasedKeyring,
    SignatureData,
    AbstractTransaction,
    AbstractFeeDelegatedTransaction,
    EthereumAccessList,
    EthereumDynamicFee,
    LegacyTransactionWrapper,
    ValueTransferWrapper,
    FeeDelegatedValueTransferWrapper,
    FeeDelegatedValueTransferWithRatioWrapper,
    ValueTransferMemoWrapper,
    FeeDelegatedValueTransferMemoWrapper,
    FeeDelegatedValueTransferMemoWithRatioWrapper,
    AccountUpdateWrapper,
    FeeDelegatedAccountUpdateWrapper,
    FeeDelegatedAccountUpdateWithRatioWrapper,
    SmartContractDeployWrapper,
    FeeDelegatedSmartContractDeployWrapper,
    FeeDelegatedSmartContractDeployWithRatioWrapper,
    SmartContractExecutionWrapper,
    FeeDelegatedSmartContractExecutionWrapper,
    FeeDelegatedSmartContractExecutionWithRatioWrapper,
    CancelWrapper,
    FeeDelegatedCancelWrapper,
    FeeDelegatedCancelWithRatioWrapper,
    ChainDataAnchoringWrapper,
    FeeDelegatedChainDataAnchoringWrapper,
    FeeDelegatedChainDataAnchoringWithRatioWrapper,
    EthereumAccessListWrapper,
    EthereumDynamicFeeWrapper,
} from 'caver-js'

const caver = new Caver()

// $ExpectType TransactionModule
caver.transaction

// $ExpectType Transaction
caver.transaction.decode('string')

// $ExpectType Promise<AbstractTransaction>
caver.transaction.getTransactionByHash('hash')

// $ExpectType string[]
caver.transaction.recoverPublicKeys('rawTx')

// $ExpectType string[]
caver.transaction.recoverFeePayerPublicKeys('rawTx')

// $ExpectType typeof AccessList
caver.transaction.utils.accessList

// $ExpectType AccessList
caver.transaction.utils.accessList.create([])

// $ExpectType AccessList
caver.transaction.utils.accessList.decode('string')

// $ExpectType EncodedAccessTuple[]
caver.transaction.utils.accessList.create([]).encodeToBytes()

// $ExpectType typeof AccessTuple
caver.transaction.utils.accessTuple

// $ExpectType AccessTuple
caver.transaction.utils.accessTuple.create('address', ['storageKey1', 'storageKey2'])

// $ExpectType EncodedAccessTuple
caver.transaction.utils.accessTuple.create('address', ['storageKey1', 'storageKey2']).encodeToByte()

// $ExpectType LegacyTransactionWrapper
caver.transaction.legacyTransaction
// $ExpectType ValueTransferWrapper
caver.transaction.valueTransfer
// $ExpectType ValueTransferMemoWrapper
caver.transaction.valueTransferMemo
// $ExpectType AccountUpdateWrapper
caver.transaction.accountUpdate
// $ExpectType SmartContractDeployWrapper
caver.transaction.smartContractDeploy
// $ExpectType SmartContractExecutionWrapper
caver.transaction.smartContractExecution
// $ExpectType CancelWrapper
caver.transaction.cancel
// $ExpectType ChainDataAnchoringWrapper
caver.transaction.chainDataAnchoring
// $ExpectType FeeDelegatedValueTransferWrapper
caver.transaction.feeDelegatedValueTransfer
// $ExpectType FeeDelegatedValueTransferMemoWrapper
caver.transaction.feeDelegatedValueTransferMemo
// $ExpectType FeeDelegatedAccountUpdateWrapper
caver.transaction.feeDelegatedAccountUpdate
// $ExpectType FeeDelegatedSmartContractDeployWrapper
caver.transaction.feeDelegatedSmartContractDeploy
// $ExpectType FeeDelegatedSmartContractExecutionWrapper
caver.transaction.feeDelegatedSmartContractExecution
// $ExpectType FeeDelegatedCancelWrapper
caver.transaction.feeDelegatedCancel
// $ExpectType FeeDelegatedChainDataAnchoringWrapper
caver.transaction.feeDelegatedChainDataAnchoring
// $ExpectType FeeDelegatedValueTransferWithRatioWrapper
caver.transaction.feeDelegatedValueTransferWithRatio
// $ExpectType FeeDelegatedValueTransferMemoWithRatioWrapper
caver.transaction.feeDelegatedValueTransferMemoWithRatio
// $ExpectType FeeDelegatedAccountUpdateWithRatioWrapper
caver.transaction.feeDelegatedAccountUpdateWithRatio
// $ExpectType FeeDelegatedSmartContractDeployWithRatioWrapper
caver.transaction.feeDelegatedSmartContractDeployWithRatio
// $ExpectType FeeDelegatedSmartContractExecutionWithRatioWrapper
caver.transaction.feeDelegatedSmartContractExecutionWithRatio
// $ExpectType FeeDelegatedCancelWithRatioWrapper
caver.transaction.feeDelegatedCancelWithRatio
// $ExpectType FeeDelegatedChainDataAnchoringWithRatioWrapper
caver.transaction.feeDelegatedChainDataAnchoringWithRatio
// $ExpectType EthereumAccessListWrapper
caver.transaction.ethereumAccessList
// $ExpectType EthereumDynamicFeeWrapper
caver.transaction.ethereumDynamicFee

// $ExpectType string
caver.transaction.type.valueTransfer
// $ExpectType string
caver.transaction.type['valueTransfer']

// $ExpectType string
caver.transaction.tag.valueTransfer
// $ExpectType string
caver.transaction.tag['valueTransfer']

// $ExpectType LegacyTransaction
new LegacyTransaction({})
// $ExpectType LegacyTransaction
LegacyTransaction.create({})
// $ExpectType LegacyTransaction
LegacyTransaction.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType LegacyTransaction
caver.transaction.legacyTransaction.create({})
// $ExpectType LegacyTransaction
LegacyTransaction.decode('string')
// $ExpectType LegacyTransaction
LegacyTransaction.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType LegacyTransaction
caver.transaction.legacyTransaction.decode('string')

// $ExpectType ValueTransfer
new ValueTransfer({})
// $ExpectType ValueTransfer
ValueTransfer.create({})
// $ExpectType ValueTransfer
ValueTransfer.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType ValueTransfer
caver.transaction.valueTransfer.create({})
// $ExpectType ValueTransfer
ValueTransfer.create('string')
// $ExpectType ValueTransfer
ValueTransfer.decode('string')
// $ExpectType ValueTransfer
ValueTransfer.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType ValueTransfer
caver.transaction.valueTransfer.decode('string')

// $ExpectType FeeDelegatedValueTransfer
new FeeDelegatedValueTransfer({})
// $ExpectType FeeDelegatedValueTransfer
FeeDelegatedValueTransfer.create({})
// $ExpectType FeeDelegatedValueTransfer
FeeDelegatedValueTransfer.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedValueTransfer
caver.transaction.feeDelegatedValueTransfer.create({})
// $ExpectType FeeDelegatedValueTransfer
FeeDelegatedValueTransfer.create('string')
// $ExpectType FeeDelegatedValueTransfer
FeeDelegatedValueTransfer.decode('string')
// $ExpectType FeeDelegatedValueTransfer
FeeDelegatedValueTransfer.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedValueTransfer
caver.transaction.feeDelegatedValueTransfer.decode('string')

// $ExpectType FeeDelegatedValueTransferWithRatio
new FeeDelegatedValueTransferWithRatio({})
// $ExpectType FeeDelegatedValueTransferWithRatio
FeeDelegatedValueTransferWithRatio.create({})
// $ExpectType FeeDelegatedValueTransferWithRatio
FeeDelegatedValueTransferWithRatio.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedValueTransferWithRatio
caver.transaction.feeDelegatedValueTransferWithRatio.create({})
// $ExpectType FeeDelegatedValueTransferWithRatio
FeeDelegatedValueTransferWithRatio.create('string')
// $ExpectType FeeDelegatedValueTransferWithRatio
FeeDelegatedValueTransferWithRatio.decode('string')
// $ExpectType FeeDelegatedValueTransferWithRatio
FeeDelegatedValueTransferWithRatio.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedValueTransferWithRatio
caver.transaction.feeDelegatedValueTransferWithRatio.decode('string')

// $ExpectType ValueTransferMemo
new ValueTransferMemo({})
// $ExpectType ValueTransferMemo
ValueTransferMemo.create({})
// $ExpectType ValueTransferMemo
ValueTransferMemo.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType ValueTransferMemo
caver.transaction.valueTransferMemo.create({})
// $ExpectType ValueTransferMemo
ValueTransferMemo.create('string')
// $ExpectType ValueTransferMemo
ValueTransferMemo.decode('string')
// $ExpectType ValueTransferMemo
ValueTransferMemo.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType ValueTransferMemo
caver.transaction.valueTransferMemo.decode('string')

// $ExpectType FeeDelegatedValueTransferMemo
new FeeDelegatedValueTransferMemo({})
// $ExpectType FeeDelegatedValueTransferMemo
FeeDelegatedValueTransferMemo.create({})
// $ExpectType FeeDelegatedValueTransferMemo
FeeDelegatedValueTransferMemo.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedValueTransferMemo
caver.transaction.feeDelegatedValueTransferMemo.create({})
// $ExpectType FeeDelegatedValueTransferMemo
FeeDelegatedValueTransferMemo.create('string')
// $ExpectType FeeDelegatedValueTransferMemo
FeeDelegatedValueTransferMemo.decode('string')
// $ExpectType FeeDelegatedValueTransferMemo
FeeDelegatedValueTransferMemo.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedValueTransferMemo
caver.transaction.feeDelegatedValueTransferMemo.decode('string')

// $ExpectType FeeDelegatedValueTransferMemoWithRatio
new FeeDelegatedValueTransferMemoWithRatio({})
// $ExpectType FeeDelegatedValueTransferMemoWithRatio
FeeDelegatedValueTransferMemoWithRatio.create({})
// $ExpectType FeeDelegatedValueTransferMemoWithRatio
FeeDelegatedValueTransferMemoWithRatio.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedValueTransferMemoWithRatio
caver.transaction.feeDelegatedValueTransferMemoWithRatio.create({})
// $ExpectType FeeDelegatedValueTransferMemoWithRatio
FeeDelegatedValueTransferMemoWithRatio.create('string')
// $ExpectType FeeDelegatedValueTransferMemoWithRatio
FeeDelegatedValueTransferMemoWithRatio.decode('string')
// $ExpectType FeeDelegatedValueTransferMemoWithRatio
FeeDelegatedValueTransferMemoWithRatio.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedValueTransferMemoWithRatio
caver.transaction.feeDelegatedValueTransferMemoWithRatio.decode('string')

// $ExpectType AccountUpdate
new AccountUpdate({})
// $ExpectType AccountUpdate
AccountUpdate.create({})
// $ExpectType AccountUpdate
AccountUpdate.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType AccountUpdate
caver.transaction.accountUpdate.create({})
// $ExpectType AccountUpdate
AccountUpdate.create('string')
// $ExpectType AccountUpdate
AccountUpdate.decode('string')
// $ExpectType AccountUpdate
AccountUpdate.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType AccountUpdate
caver.transaction.accountUpdate.decode('string')

// $ExpectType FeeDelegatedAccountUpdate
new FeeDelegatedAccountUpdate({})
// $ExpectType FeeDelegatedAccountUpdate
FeeDelegatedAccountUpdate.create({})
// $ExpectType FeeDelegatedAccountUpdate
FeeDelegatedAccountUpdate.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedAccountUpdate
caver.transaction.feeDelegatedAccountUpdate.create({})
// $ExpectType FeeDelegatedAccountUpdate
FeeDelegatedAccountUpdate.create('string')
// $ExpectType FeeDelegatedAccountUpdate
FeeDelegatedAccountUpdate.decode('string')
// $ExpectType FeeDelegatedAccountUpdate
FeeDelegatedAccountUpdate.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedAccountUpdate
caver.transaction.feeDelegatedAccountUpdate.decode('string')

// $ExpectType FeeDelegatedAccountUpdateWithRatio
new FeeDelegatedAccountUpdateWithRatio({})
// $ExpectType FeeDelegatedAccountUpdateWithRatio
FeeDelegatedAccountUpdateWithRatio.create({})
// $ExpectType FeeDelegatedAccountUpdateWithRatio
FeeDelegatedAccountUpdateWithRatio.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedAccountUpdateWithRatio
caver.transaction.feeDelegatedAccountUpdateWithRatio.create({})
// $ExpectType FeeDelegatedAccountUpdateWithRatio
FeeDelegatedAccountUpdateWithRatio.create('string')
// $ExpectType FeeDelegatedAccountUpdateWithRatio
FeeDelegatedAccountUpdateWithRatio.decode('string')
// $ExpectType FeeDelegatedAccountUpdateWithRatio
FeeDelegatedAccountUpdateWithRatio.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedAccountUpdateWithRatio
caver.transaction.feeDelegatedAccountUpdateWithRatio.decode('string')

// $ExpectType SmartContractDeploy
new SmartContractDeploy({})
// $ExpectType SmartContractDeploy
SmartContractDeploy.create({})
// $ExpectType SmartContractDeploy
SmartContractDeploy.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType SmartContractDeploy
caver.transaction.smartContractDeploy.create({})
// $ExpectType SmartContractDeploy
SmartContractDeploy.create('string')
// $ExpectType SmartContractDeploy
SmartContractDeploy.decode('string')
// $ExpectType SmartContractDeploy
SmartContractDeploy.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType SmartContractDeploy
caver.transaction.smartContractDeploy.decode('string')

// $ExpectType FeeDelegatedSmartContractDeploy
new FeeDelegatedSmartContractDeploy({})
// $ExpectType FeeDelegatedSmartContractDeploy
FeeDelegatedSmartContractDeploy.create({})
// $ExpectType FeeDelegatedSmartContractDeploy
FeeDelegatedSmartContractDeploy.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedSmartContractDeploy
caver.transaction.feeDelegatedSmartContractDeploy.create({})
// $ExpectType FeeDelegatedSmartContractDeploy
FeeDelegatedSmartContractDeploy.create('string')
// $ExpectType FeeDelegatedSmartContractDeploy
FeeDelegatedSmartContractDeploy.decode('string')
// $ExpectType FeeDelegatedSmartContractDeploy
FeeDelegatedSmartContractDeploy.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedSmartContractDeploy
caver.transaction.feeDelegatedSmartContractDeploy.decode('string')

// $ExpectType FeeDelegatedSmartContractDeployWithRatio
new FeeDelegatedSmartContractDeployWithRatio({})
// $ExpectType FeeDelegatedSmartContractDeployWithRatio
FeeDelegatedSmartContractDeployWithRatio.create({})
// $ExpectType FeeDelegatedSmartContractDeployWithRatio
FeeDelegatedSmartContractDeployWithRatio.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedSmartContractDeployWithRatio
caver.transaction.feeDelegatedSmartContractDeployWithRatio.create({})
// $ExpectType FeeDelegatedSmartContractDeployWithRatio
FeeDelegatedSmartContractDeployWithRatio.create('string')
// $ExpectType FeeDelegatedSmartContractDeployWithRatio
FeeDelegatedSmartContractDeployWithRatio.decode('string')
// $ExpectType FeeDelegatedSmartContractDeployWithRatio
FeeDelegatedSmartContractDeployWithRatio.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedSmartContractDeployWithRatio
caver.transaction.feeDelegatedSmartContractDeployWithRatio.decode('string')

// $ExpectType SmartContractExecution
new SmartContractExecution({})
// $ExpectType SmartContractExecution
SmartContractExecution.create({})
// $ExpectType SmartContractExecution
SmartContractExecution.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType SmartContractExecution
caver.transaction.smartContractExecution.create({})
// $ExpectType SmartContractExecution
SmartContractExecution.create('string')
// $ExpectType SmartContractExecution
SmartContractExecution.decode('string')
// $ExpectType SmartContractExecution
SmartContractExecution.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType SmartContractExecution
caver.transaction.smartContractExecution.decode('string')

// $ExpectType FeeDelegatedSmartContractExecution
new FeeDelegatedSmartContractExecution({})
// $ExpectType FeeDelegatedSmartContractExecution
FeeDelegatedSmartContractExecution.create({})
// $ExpectType FeeDelegatedSmartContractExecution
FeeDelegatedSmartContractExecution.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedSmartContractExecution
caver.transaction.feeDelegatedSmartContractExecution.create({})
// $ExpectType FeeDelegatedSmartContractExecution
FeeDelegatedSmartContractExecution.create('string')
// $ExpectType FeeDelegatedSmartContractExecution
FeeDelegatedSmartContractExecution.decode('string')
// $ExpectType FeeDelegatedSmartContractExecution
FeeDelegatedSmartContractExecution.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedSmartContractExecution
caver.transaction.feeDelegatedSmartContractExecution.decode('string')

// $ExpectType FeeDelegatedSmartContractExecutionWithRatio
new FeeDelegatedSmartContractExecutionWithRatio({})
// $ExpectType FeeDelegatedSmartContractExecutionWithRatio
FeeDelegatedSmartContractExecutionWithRatio.create({})
// $ExpectType FeeDelegatedSmartContractExecutionWithRatio
FeeDelegatedSmartContractExecutionWithRatio.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedSmartContractExecutionWithRatio
caver.transaction.feeDelegatedSmartContractExecutionWithRatio.create({})
// $ExpectType FeeDelegatedSmartContractExecutionWithRatio
FeeDelegatedSmartContractExecutionWithRatio.create('string')
// $ExpectType FeeDelegatedSmartContractExecutionWithRatio
FeeDelegatedSmartContractExecutionWithRatio.decode('string')
// $ExpectType FeeDelegatedSmartContractExecutionWithRatio
FeeDelegatedSmartContractExecutionWithRatio.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedSmartContractExecutionWithRatio
caver.transaction.feeDelegatedSmartContractExecutionWithRatio.decode('string')

// $ExpectType Cancel
new Cancel({})
// $ExpectType Cancel
Cancel.create({})
// $ExpectType Cancel
Cancel.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType Cancel
caver.transaction.cancel.create({})
// $ExpectType Cancel
Cancel.create('string')
// $ExpectType Cancel
Cancel.decode('string')
// $ExpectType Cancel
Cancel.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType Cancel
caver.transaction.cancel.decode('string')

// $ExpectType FeeDelegatedCancel
new FeeDelegatedCancel({})
// $ExpectType FeeDelegatedCancel
FeeDelegatedCancel.create({})
// $ExpectType FeeDelegatedCancel
FeeDelegatedCancel.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedCancel
caver.transaction.feeDelegatedCancel.create({})
// $ExpectType FeeDelegatedCancel
FeeDelegatedCancel.create('string')
// $ExpectType FeeDelegatedCancel
FeeDelegatedCancel.decode('string')
// $ExpectType FeeDelegatedCancel
FeeDelegatedCancel.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedCancel
caver.transaction.feeDelegatedCancel.decode('string')

// $ExpectType FeeDelegatedCancelWithRatio
new FeeDelegatedCancelWithRatio({})
// $ExpectType FeeDelegatedCancelWithRatio
FeeDelegatedCancelWithRatio.create({})
// $ExpectType FeeDelegatedCancelWithRatio
FeeDelegatedCancelWithRatio.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedCancelWithRatio
caver.transaction.feeDelegatedCancelWithRatio.create({})
// $ExpectType FeeDelegatedCancelWithRatio
FeeDelegatedCancelWithRatio.create('string')
// $ExpectType FeeDelegatedCancelWithRatio
FeeDelegatedCancelWithRatio.decode('string')
// $ExpectType FeeDelegatedCancelWithRatio
FeeDelegatedCancelWithRatio.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedCancelWithRatio
caver.transaction.feeDelegatedCancelWithRatio.decode('string')

// $ExpectType ChainDataAnchoring
new ChainDataAnchoring({})
// $ExpectType ChainDataAnchoring
ChainDataAnchoring.create({})
// $ExpectType ChainDataAnchoring
ChainDataAnchoring.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType ChainDataAnchoring
caver.transaction.chainDataAnchoring.create({})
// $ExpectType ChainDataAnchoring
ChainDataAnchoring.create('string')
// $ExpectType ChainDataAnchoring
ChainDataAnchoring.decode('string')
// $ExpectType ChainDataAnchoring
ChainDataAnchoring.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType ChainDataAnchoring
caver.transaction.chainDataAnchoring.decode('string')

// $ExpectType FeeDelegatedChainDataAnchoring
new FeeDelegatedChainDataAnchoring({})
// $ExpectType FeeDelegatedChainDataAnchoring
FeeDelegatedChainDataAnchoring.create({})
// $ExpectType FeeDelegatedChainDataAnchoring
FeeDelegatedChainDataAnchoring.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedChainDataAnchoring
caver.transaction.feeDelegatedChainDataAnchoring.create({})
// $ExpectType FeeDelegatedChainDataAnchoring
FeeDelegatedChainDataAnchoring.create('string')
// $ExpectType FeeDelegatedChainDataAnchoring
FeeDelegatedChainDataAnchoring.decode('string')
// $ExpectType FeeDelegatedChainDataAnchoring
FeeDelegatedChainDataAnchoring.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedChainDataAnchoring
caver.transaction.feeDelegatedChainDataAnchoring.decode('string')

// $ExpectType FeeDelegatedChainDataAnchoringWithRatio
new FeeDelegatedChainDataAnchoringWithRatio({})
// $ExpectType FeeDelegatedChainDataAnchoringWithRatio
FeeDelegatedChainDataAnchoringWithRatio.create({})
// $ExpectType FeeDelegatedChainDataAnchoringWithRatio
FeeDelegatedChainDataAnchoringWithRatio.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedChainDataAnchoringWithRatio
caver.transaction.feeDelegatedChainDataAnchoringWithRatio.create({})
// $ExpectType FeeDelegatedChainDataAnchoringWithRatio
FeeDelegatedChainDataAnchoringWithRatio.create('string')
// $ExpectType FeeDelegatedChainDataAnchoringWithRatio
FeeDelegatedChainDataAnchoringWithRatio.decode('string')
// $ExpectType FeeDelegatedChainDataAnchoringWithRatio
FeeDelegatedChainDataAnchoringWithRatio.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType FeeDelegatedChainDataAnchoringWithRatio
caver.transaction.feeDelegatedChainDataAnchoringWithRatio.decode('string')

// $ExpectType EthereumAccessList
new EthereumAccessList({})
// $ExpectType EthereumAccessList
EthereumAccessList.create({})
// $ExpectType EthereumAccessList
EthereumAccessList.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType EthereumAccessList
caver.transaction.ethereumAccessList.create({})
// $ExpectType EthereumAccessList
EthereumAccessList.create('string')
// $ExpectType EthereumAccessList
EthereumAccessList.decode('string')
// $ExpectType EthereumAccessList
EthereumAccessList.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType EthereumAccessList
caver.transaction.ethereumAccessList.decode('string')

// $ExpectType EthereumDynamicFee
new EthereumDynamicFee({})
// $ExpectType EthereumDynamicFee
EthereumDynamicFee.create({})
// $ExpectType EthereumDynamicFee
EthereumDynamicFee.create({}, caver.rpc.klay.klaytnCall)
// $ExpectType EthereumDynamicFee
caver.transaction.ethereumDynamicFee.create({})
// $ExpectType EthereumDynamicFee
EthereumDynamicFee.create('string')
// $ExpectType EthereumDynamicFee
EthereumDynamicFee.decode('string')
// $ExpectType EthereumDynamicFee
EthereumDynamicFee.decode('string', caver.rpc.klay.klaytnCall)
// $ExpectType EthereumDynamicFee
caver.transaction.ethereumDynamicFee.decode('string')

const address = '0xde39030c0b51c01a83fc819fb79d47c90d6a3a60'
const prvKeys = [
    '0x99305a113c6182985e1ee6ec636ee5e8d0b93fcf3af7f72f8177938afca688f1',
    '0x97f2c7da1471122b0d0aa54d1ec6b0cc171c81d97e13d27c204d838f76c98310',
]
const keyrings = {
    single: new SingleKeyring(address, prvKeys[0]),
    multiple: new MultipleKeyring(address, prvKeys),
    roleBased: new RoleBasedKeyring(address, [prvKeys, prvKeys, prvKeys]),
}
const sig = new SignatureData(['0x01', '0x', '0x'])

const legacyTransaction = new LegacyTransaction({})

// $ExpectType string
legacyTransaction.getRLPEncoding()

// $ExpectType string
legacyTransaction.getCommonRLPEncodingForSignature()

// $ExpectType Promise<AbstractTransaction>
legacyTransaction.sign('string')
// $ExpectType Promise<AbstractTransaction>
legacyTransaction.sign(keyrings.single)
// $ExpectType Promise<AbstractTransaction>
legacyTransaction.sign(keyrings.multiple)
// $ExpectType Promise<AbstractTransaction>
legacyTransaction.sign(keyrings.roleBased)
// $ExpectType Promise<AbstractTransaction>
legacyTransaction.sign('string', 0)
// $ExpectType Promise<AbstractTransaction>
legacyTransaction.sign(keyrings.single, 0)
// $ExpectType Promise<AbstractTransaction>
legacyTransaction.sign(keyrings.multiple, 0)
// $ExpectType Promise<AbstractTransaction>
legacyTransaction.sign(keyrings.roleBased, 0)
// $ExpectType Promise<AbstractTransaction>
legacyTransaction.sign('string', (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
legacyTransaction.sign(keyrings.single, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
legacyTransaction.sign(keyrings.multiple, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
legacyTransaction.sign(keyrings.roleBased, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
legacyTransaction.sign('string', 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
legacyTransaction.sign(keyrings.single, 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
legacyTransaction.sign(keyrings.multiple, 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
legacyTransaction.sign(keyrings.roleBased, 0, (tx: AbstractTransaction) => '')

// $ExpectType void
legacyTransaction.appendSignatures(sig)
// $ExpectType void
legacyTransaction.appendSignatures([sig, sig])
// $ExpectType void
legacyTransaction.appendSignatures(['0x01', '0x', '0x'])
// $ExpectType void
legacyTransaction.appendSignatures([['0x01', '0x', '0x'], ['0x01', '0x', '0x']])

// $ExpectType string
legacyTransaction.combineSignedRawTransactions(['rlpEncoded1', 'rlpEncoded2'])

// $ExpectType string
legacyTransaction.getRawTransaction()

// $ExpectType string
legacyTransaction.getTransactionHash()

// $ExpectType string
legacyTransaction.getSenderTxHash()

// $ExpectType string
legacyTransaction.getRLPEncodingForSignature()

// $ExpectType string[]
legacyTransaction.recoverPublicKeys()

// $ExpectType Promise<void>
legacyTransaction.fillTransaction()

// $ExpectType void
legacyTransaction.validateOptionalValues()

// $ExpectType string
legacyTransaction.type
// $ExpectType string
legacyTransaction.from
// $ExpectType string
legacyTransaction.nonce
// $ExpectType string
legacyTransaction.gas
// $ExpectType string
legacyTransaction.gasPrice
// $ExpectType string
legacyTransaction.chainId
// $ExpectType SignatureData | SignatureData[]
legacyTransaction.signatures
// $ExpectType string
legacyTransaction.to
// $ExpectType string
legacyTransaction.value
// $ExpectType string
legacyTransaction.input
// $ExpectType string
legacyTransaction.data
// $ExpectType KlaytnCall
legacyTransaction.klaytnCall

const valueTransfer = new ValueTransfer({})

// $ExpectType string
valueTransfer.getRLPEncoding()

// $ExpectType string
valueTransfer.getCommonRLPEncodingForSignature()

// $ExpectType Promise<AbstractTransaction>
valueTransfer.sign('string')
// $ExpectType Promise<AbstractTransaction>
valueTransfer.sign(keyrings.single)
// $ExpectType Promise<AbstractTransaction>
valueTransfer.sign(keyrings.multiple)
// $ExpectType Promise<AbstractTransaction>
valueTransfer.sign(keyrings.roleBased)
// $ExpectType Promise<AbstractTransaction>
valueTransfer.sign('string', 0)
// $ExpectType Promise<AbstractTransaction>
valueTransfer.sign(keyrings.single, 0)
// $ExpectType Promise<AbstractTransaction>
valueTransfer.sign(keyrings.multiple, 0)
// $ExpectType Promise<AbstractTransaction>
valueTransfer.sign(keyrings.roleBased, 0)
// $ExpectType Promise<AbstractTransaction>
valueTransfer.sign('string', (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
valueTransfer.sign(keyrings.single, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
valueTransfer.sign(keyrings.multiple, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
valueTransfer.sign(keyrings.roleBased, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
valueTransfer.sign('string', 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
valueTransfer.sign(keyrings.single, 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
valueTransfer.sign(keyrings.multiple, 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
valueTransfer.sign(keyrings.roleBased, 0, (tx: AbstractTransaction) => '')

// $ExpectType void
valueTransfer.appendSignatures(sig)
// $ExpectType void
valueTransfer.appendSignatures([sig, sig])
// $ExpectType void
valueTransfer.appendSignatures(['0x01', '0x', '0x'])
// $ExpectType void
valueTransfer.appendSignatures([['0x01', '0x', '0x'], ['0x01', '0x', '0x']])

// $ExpectType string
valueTransfer.combineSignedRawTransactions(['rlpEncoded1', 'rlpEncoded2'])

// $ExpectType string
valueTransfer.getRawTransaction()

// $ExpectType string
valueTransfer.getTransactionHash()

// $ExpectType string
valueTransfer.getSenderTxHash()

// $ExpectType string
valueTransfer.getRLPEncodingForSignature()

// $ExpectType string[]
valueTransfer.recoverPublicKeys()

// $ExpectType Promise<void>
valueTransfer.fillTransaction()

// $ExpectType void
valueTransfer.validateOptionalValues()

// $ExpectType string
valueTransfer.type
// $ExpectType string
valueTransfer.from
// $ExpectType string
valueTransfer.nonce
// $ExpectType string
valueTransfer.gas
// $ExpectType string
valueTransfer.gasPrice
// $ExpectType string
valueTransfer.chainId
// $ExpectType SignatureData | SignatureData[]
valueTransfer.signatures
// $ExpectType string
valueTransfer.to
// $ExpectType string
valueTransfer.value
// $ExpectType KlaytnCall
valueTransfer.klaytnCall

const valueTransferMemo = new ValueTransferMemo({})

// $ExpectType string
valueTransferMemo.getRLPEncoding()

// $ExpectType string
valueTransferMemo.getCommonRLPEncodingForSignature()

// $ExpectType Promise<AbstractTransaction>
valueTransferMemo.sign('string')
// $ExpectType Promise<AbstractTransaction>
valueTransferMemo.sign(keyrings.single)
// $ExpectType Promise<AbstractTransaction>
valueTransferMemo.sign(keyrings.multiple)
// $ExpectType Promise<AbstractTransaction>
valueTransferMemo.sign(keyrings.roleBased)
// $ExpectType Promise<AbstractTransaction>
valueTransferMemo.sign('string', 0)
// $ExpectType Promise<AbstractTransaction>
valueTransferMemo.sign(keyrings.single, 0)
// $ExpectType Promise<AbstractTransaction>
valueTransferMemo.sign(keyrings.multiple, 0)
// $ExpectType Promise<AbstractTransaction>
valueTransferMemo.sign(keyrings.roleBased, 0)
// $ExpectType Promise<AbstractTransaction>
valueTransferMemo.sign('string', (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
valueTransferMemo.sign(keyrings.single, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
valueTransferMemo.sign(keyrings.multiple, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
valueTransferMemo.sign(keyrings.roleBased, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
valueTransferMemo.sign('string', 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
valueTransferMemo.sign(keyrings.single, 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
valueTransferMemo.sign(keyrings.multiple, 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
valueTransferMemo.sign(keyrings.roleBased, 0, (tx: AbstractTransaction) => '')

// $ExpectType void
valueTransferMemo.appendSignatures(sig)
// $ExpectType void
valueTransferMemo.appendSignatures([sig, sig])
// $ExpectType void
valueTransferMemo.appendSignatures(['0x01', '0x', '0x'])
// $ExpectType void
valueTransferMemo.appendSignatures([['0x01', '0x', '0x'], ['0x01', '0x', '0x']])

// $ExpectType string
valueTransferMemo.combineSignedRawTransactions(['rlpEncoded1', 'rlpEncoded2'])

// $ExpectType string
valueTransferMemo.getRawTransaction()

// $ExpectType string
valueTransferMemo.getTransactionHash()

// $ExpectType string
valueTransferMemo.getSenderTxHash()

// $ExpectType string
valueTransferMemo.getRLPEncodingForSignature()

// $ExpectType string[]
valueTransferMemo.recoverPublicKeys()

// $ExpectType Promise<void>
valueTransferMemo.fillTransaction()

// $ExpectType void
valueTransferMemo.validateOptionalValues()

// $ExpectType string
valueTransferMemo.type
// $ExpectType string
valueTransferMemo.from
// $ExpectType string
valueTransferMemo.nonce
// $ExpectType string
valueTransferMemo.gas
// $ExpectType string
valueTransferMemo.gasPrice
// $ExpectType string
valueTransferMemo.chainId
// $ExpectType SignatureData | SignatureData[]
valueTransferMemo.signatures
// $ExpectType string
valueTransferMemo.to
// $ExpectType string
valueTransferMemo.value
// $ExpectType string
valueTransferMemo.input
// $ExpectType string
valueTransferMemo.data
// $ExpectType KlaytnCall
valueTransferMemo.klaytnCall

const accountUpdate = new AccountUpdate({})

// $ExpectType string
accountUpdate.getRLPEncoding()

// $ExpectType string
accountUpdate.getCommonRLPEncodingForSignature()

// $ExpectType Promise<AbstractTransaction>
accountUpdate.sign('string')
// $ExpectType Promise<AbstractTransaction>
accountUpdate.sign(keyrings.single)
// $ExpectType Promise<AbstractTransaction>
accountUpdate.sign(keyrings.multiple)
// $ExpectType Promise<AbstractTransaction>
accountUpdate.sign(keyrings.roleBased)
// $ExpectType Promise<AbstractTransaction>
accountUpdate.sign('string', 0)
// $ExpectType Promise<AbstractTransaction>
accountUpdate.sign(keyrings.single, 0)
// $ExpectType Promise<AbstractTransaction>
accountUpdate.sign(keyrings.multiple, 0)
// $ExpectType Promise<AbstractTransaction>
accountUpdate.sign(keyrings.roleBased, 0)
// $ExpectType Promise<AbstractTransaction>
accountUpdate.sign('string', (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
accountUpdate.sign(keyrings.single, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
accountUpdate.sign(keyrings.multiple, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
accountUpdate.sign(keyrings.roleBased, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
accountUpdate.sign('string', 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
accountUpdate.sign(keyrings.single, 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
accountUpdate.sign(keyrings.multiple, 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
accountUpdate.sign(keyrings.roleBased, 0, (tx: AbstractTransaction) => '')

// $ExpectType void
accountUpdate.appendSignatures(sig)
// $ExpectType void
accountUpdate.appendSignatures([sig, sig])
// $ExpectType void
accountUpdate.appendSignatures(['0x01', '0x', '0x'])
// $ExpectType void
accountUpdate.appendSignatures([['0x01', '0x', '0x'], ['0x01', '0x', '0x']])

// $ExpectType string
accountUpdate.combineSignedRawTransactions(['rlpEncoded1', 'rlpEncoded2'])

// $ExpectType string
accountUpdate.getRawTransaction()

// $ExpectType string
accountUpdate.getTransactionHash()

// $ExpectType string
accountUpdate.getSenderTxHash()

// $ExpectType string
accountUpdate.getRLPEncodingForSignature()

// $ExpectType string[]
accountUpdate.recoverPublicKeys()

// $ExpectType Promise<void>
accountUpdate.fillTransaction()

// $ExpectType void
accountUpdate.validateOptionalValues()

// $ExpectType string
accountUpdate.type
// $ExpectType string
accountUpdate.from
// $ExpectType string
accountUpdate.nonce
// $ExpectType string
accountUpdate.gas
// $ExpectType string
accountUpdate.gasPrice
// $ExpectType string
accountUpdate.chainId
// $ExpectType SignatureData | SignatureData[]
accountUpdate.signatures
// $ExpectType Account
accountUpdate.account
// $ExpectType KlaytnCall
accountUpdate.klaytnCall

const smartContractDeploy = new SmartContractDeploy({})

// $ExpectType string
smartContractDeploy.getRLPEncoding()

// $ExpectType string
smartContractDeploy.getCommonRLPEncodingForSignature()

// $ExpectType Promise<AbstractTransaction>
smartContractDeploy.sign('string')
// $ExpectType Promise<AbstractTransaction>
smartContractDeploy.sign(keyrings.single)
// $ExpectType Promise<AbstractTransaction>
smartContractDeploy.sign(keyrings.multiple)
// $ExpectType Promise<AbstractTransaction>
smartContractDeploy.sign(keyrings.roleBased)
// $ExpectType Promise<AbstractTransaction>
smartContractDeploy.sign('string', 0)
// $ExpectType Promise<AbstractTransaction>
smartContractDeploy.sign(keyrings.single, 0)
// $ExpectType Promise<AbstractTransaction>
smartContractDeploy.sign(keyrings.multiple, 0)
// $ExpectType Promise<AbstractTransaction>
smartContractDeploy.sign(keyrings.roleBased, 0)
// $ExpectType Promise<AbstractTransaction>
smartContractDeploy.sign('string', (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
smartContractDeploy.sign(keyrings.single, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
smartContractDeploy.sign(keyrings.multiple, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
smartContractDeploy.sign(keyrings.roleBased, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
smartContractDeploy.sign('string', 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
smartContractDeploy.sign(keyrings.single, 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
smartContractDeploy.sign(keyrings.multiple, 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
smartContractDeploy.sign(keyrings.roleBased, 0, (tx: AbstractTransaction) => '')

// $ExpectType void
smartContractDeploy.appendSignatures(sig)
// $ExpectType void
smartContractDeploy.appendSignatures([sig, sig])
// $ExpectType void
smartContractDeploy.appendSignatures(['0x01', '0x', '0x'])
// $ExpectType void
smartContractDeploy.appendSignatures([['0x01', '0x', '0x'], ['0x01', '0x', '0x']])

// $ExpectType string
smartContractDeploy.combineSignedRawTransactions(['rlpEncoded1', 'rlpEncoded2'])

// $ExpectType string
smartContractDeploy.getRawTransaction()

// $ExpectType string
smartContractDeploy.getTransactionHash()

// $ExpectType string
smartContractDeploy.getSenderTxHash()

// $ExpectType string
smartContractDeploy.getRLPEncodingForSignature()

// $ExpectType string[]
smartContractDeploy.recoverPublicKeys()

// $ExpectType Promise<void>
smartContractDeploy.fillTransaction()

// $ExpectType void
smartContractDeploy.validateOptionalValues()

// $ExpectType string
smartContractDeploy.type
// $ExpectType string
smartContractDeploy.from
// $ExpectType string
smartContractDeploy.nonce
// $ExpectType string
smartContractDeploy.gas
// $ExpectType string
smartContractDeploy.gasPrice
// $ExpectType string
smartContractDeploy.chainId
// $ExpectType SignatureData | SignatureData[]
smartContractDeploy.signatures
// $ExpectType string
smartContractDeploy.to
// $ExpectType string
smartContractDeploy.value
// $ExpectType string
smartContractDeploy.input
// $ExpectType string
smartContractDeploy.data
// $ExpectType boolean
smartContractDeploy.humanReadable
// $ExpectType string
smartContractDeploy.codeFormat
// $ExpectType KlaytnCall
smartContractDeploy.klaytnCall

const smartContractExecution = new SmartContractExecution({})

// $ExpectType string
smartContractExecution.getRLPEncoding()

// $ExpectType string
smartContractExecution.getCommonRLPEncodingForSignature()

// $ExpectType Promise<AbstractTransaction>
smartContractExecution.sign('string')
// $ExpectType Promise<AbstractTransaction>
smartContractExecution.sign(keyrings.single)
// $ExpectType Promise<AbstractTransaction>
smartContractExecution.sign(keyrings.multiple)
// $ExpectType Promise<AbstractTransaction>
smartContractExecution.sign(keyrings.roleBased)
// $ExpectType Promise<AbstractTransaction>
smartContractExecution.sign('string', 0)
// $ExpectType Promise<AbstractTransaction>
smartContractExecution.sign(keyrings.single, 0)
// $ExpectType Promise<AbstractTransaction>
smartContractExecution.sign(keyrings.multiple, 0)
// $ExpectType Promise<AbstractTransaction>
smartContractExecution.sign(keyrings.roleBased, 0)
// $ExpectType Promise<AbstractTransaction>
smartContractExecution.sign('string', (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
smartContractExecution.sign(keyrings.single, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
smartContractExecution.sign(keyrings.multiple, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
smartContractExecution.sign(keyrings.roleBased, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
smartContractExecution.sign('string', 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
smartContractExecution.sign(keyrings.single, 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
smartContractExecution.sign(keyrings.multiple, 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
smartContractExecution.sign(keyrings.roleBased, 0, (tx: AbstractTransaction) => '')

// $ExpectType void
smartContractExecution.appendSignatures(sig)
// $ExpectType void
smartContractExecution.appendSignatures([sig, sig])
// $ExpectType void
smartContractExecution.appendSignatures(['0x01', '0x', '0x'])
// $ExpectType void
smartContractExecution.appendSignatures([['0x01', '0x', '0x'], ['0x01', '0x', '0x']])

// $ExpectType string
smartContractExecution.combineSignedRawTransactions(['rlpEncoded1', 'rlpEncoded2'])

// $ExpectType string
smartContractExecution.getRawTransaction()

// $ExpectType string
smartContractExecution.getTransactionHash()

// $ExpectType string
smartContractExecution.getSenderTxHash()

// $ExpectType string
smartContractExecution.getRLPEncodingForSignature()

// $ExpectType string[]
smartContractExecution.recoverPublicKeys()

// $ExpectType Promise<void>
smartContractExecution.fillTransaction()

// $ExpectType void
smartContractExecution.validateOptionalValues()

// $ExpectType string
smartContractExecution.type
// $ExpectType string
smartContractExecution.from
// $ExpectType string
smartContractExecution.nonce
// $ExpectType string
smartContractExecution.gas
// $ExpectType string
smartContractExecution.gasPrice
// $ExpectType string
smartContractExecution.chainId
// $ExpectType SignatureData | SignatureData[]
smartContractExecution.signatures
// $ExpectType string
smartContractExecution.to
// $ExpectType string
smartContractExecution.value
// $ExpectType string
smartContractExecution.input
// $ExpectType string
smartContractExecution.data
// $ExpectType KlaytnCall
smartContractExecution.klaytnCall

const cancel = new Cancel({})

// $ExpectType string
cancel.getRLPEncoding()

// $ExpectType string
cancel.getCommonRLPEncodingForSignature()

// $ExpectType Promise<AbstractTransaction>
cancel.sign('string')
// $ExpectType Promise<AbstractTransaction>
cancel.sign(keyrings.single)
// $ExpectType Promise<AbstractTransaction>
cancel.sign(keyrings.multiple)
// $ExpectType Promise<AbstractTransaction>
cancel.sign(keyrings.roleBased)
// $ExpectType Promise<AbstractTransaction>
cancel.sign('string', 0)
// $ExpectType Promise<AbstractTransaction>
cancel.sign(keyrings.single, 0)
// $ExpectType Promise<AbstractTransaction>
cancel.sign(keyrings.multiple, 0)
// $ExpectType Promise<AbstractTransaction>
cancel.sign(keyrings.roleBased, 0)
// $ExpectType Promise<AbstractTransaction>
cancel.sign('string', (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
cancel.sign(keyrings.single, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
cancel.sign(keyrings.multiple, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
cancel.sign(keyrings.roleBased, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
cancel.sign('string', 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
cancel.sign(keyrings.single, 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
cancel.sign(keyrings.multiple, 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
cancel.sign(keyrings.roleBased, 0, (tx: AbstractTransaction) => '')

// $ExpectType void
cancel.appendSignatures(sig)
// $ExpectType void
cancel.appendSignatures([sig, sig])
// $ExpectType void
cancel.appendSignatures(['0x01', '0x', '0x'])
// $ExpectType void
cancel.appendSignatures([['0x01', '0x', '0x'], ['0x01', '0x', '0x']])

// $ExpectType string
cancel.combineSignedRawTransactions(['rlpEncoded1', 'rlpEncoded2'])

// $ExpectType string
cancel.getRawTransaction()

// $ExpectType string
cancel.getTransactionHash()

// $ExpectType string
cancel.getSenderTxHash()

// $ExpectType string
cancel.getRLPEncodingForSignature()

// $ExpectType string[]
cancel.recoverPublicKeys()

// $ExpectType Promise<void>
cancel.fillTransaction()

// $ExpectType void
cancel.validateOptionalValues()

// $ExpectType string
cancel.type
// $ExpectType string
cancel.from
// $ExpectType string
cancel.nonce
// $ExpectType string
cancel.gas
// $ExpectType string
cancel.gasPrice
// $ExpectType string
cancel.chainId
// $ExpectType SignatureData | SignatureData[]
cancel.signatures
// $ExpectType KlaytnCall
cancel.klaytnCall

const chainDataAnchoring = new ChainDataAnchoring({})

// $ExpectType string
chainDataAnchoring.getRLPEncoding()

// $ExpectType string
chainDataAnchoring.getCommonRLPEncodingForSignature()

// $ExpectType Promise<AbstractTransaction>
chainDataAnchoring.sign('string')
// $ExpectType Promise<AbstractTransaction>
chainDataAnchoring.sign(keyrings.single)
// $ExpectType Promise<AbstractTransaction>
chainDataAnchoring.sign(keyrings.multiple)
// $ExpectType Promise<AbstractTransaction>
chainDataAnchoring.sign(keyrings.roleBased)
// $ExpectType Promise<AbstractTransaction>
chainDataAnchoring.sign('string', 0)
// $ExpectType Promise<AbstractTransaction>
chainDataAnchoring.sign(keyrings.single, 0)
// $ExpectType Promise<AbstractTransaction>
chainDataAnchoring.sign(keyrings.multiple, 0)
// $ExpectType Promise<AbstractTransaction>
chainDataAnchoring.sign(keyrings.roleBased, 0)
// $ExpectType Promise<AbstractTransaction>
chainDataAnchoring.sign('string', (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
chainDataAnchoring.sign(keyrings.single, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
chainDataAnchoring.sign(keyrings.multiple, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
chainDataAnchoring.sign(keyrings.roleBased, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
chainDataAnchoring.sign('string', 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
chainDataAnchoring.sign(keyrings.single, 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
chainDataAnchoring.sign(keyrings.multiple, 0, (tx: AbstractTransaction) => '')
// $ExpectType Promise<AbstractTransaction>
chainDataAnchoring.sign(keyrings.roleBased, 0, (tx: AbstractTransaction) => '')

// $ExpectType void
chainDataAnchoring.appendSignatures(sig)
// $ExpectType void
chainDataAnchoring.appendSignatures([sig, sig])
// $ExpectType void
chainDataAnchoring.appendSignatures(['0x01', '0x', '0x'])
// $ExpectType void
chainDataAnchoring.appendSignatures([['0x01', '0x', '0x'], ['0x01', '0x', '0x']])

// $ExpectType string
chainDataAnchoring.combineSignedRawTransactions(['rlpEncoded1', 'rlpEncoded2'])

// $ExpectType string
chainDataAnchoring.getRawTransaction()

// $ExpectType string
chainDataAnchoring.getTransactionHash()

// $ExpectType string
chainDataAnchoring.getSenderTxHash()

// $ExpectType string
chainDataAnchoring.getRLPEncodingForSignature()

// $ExpectType string[]
chainDataAnchoring.recoverPublicKeys()

// $ExpectType Promise<void>
chainDataAnchoring.fillTransaction()

// $ExpectType void
chainDataAnchoring.validateOptionalValues()

// $ExpectType string
chainDataAnchoring.type
// $ExpectType string
chainDataAnchoring.from
// $ExpectType string
chainDataAnchoring.nonce
// $ExpectType string
chainDataAnchoring.gas
// $ExpectType string
chainDataAnchoring.gasPrice
// $ExpectType string
chainDataAnchoring.chainId
// $ExpectType SignatureData | SignatureData[]
chainDataAnchoring.signatures
// $ExpectType string
chainDataAnchoring.input
// $ExpectType KlaytnCall
chainDataAnchoring.klaytnCall

const feeDelegatedValueTransfer = new FeeDelegatedValueTransfer({})

// $ExpectType string
feeDelegatedValueTransfer.getRLPEncoding()

// $ExpectType string
feeDelegatedValueTransfer.getCommonRLPEncodingForSignature()

// $ExpectType Promise<AbstractTransaction>
feeDelegatedValueTransfer.sign('string')
// $ExpectType Promise<AbstractTransaction>
feeDelegatedValueTransfer.sign(keyrings.single)
// $ExpectType Promise<AbstractTransaction>
feeDelegatedValueTransfer.sign(keyrings.multiple)
/