model

type CounterpartyPhononCard interface {
	GetCertificate() (*cert.CardCertificate, error)
	CardPair(initPairingData []byte) (cardPairData []byte, err error)
	CardPair2(cardPairData []byte) (cardPairData2 []byte, err error)
	FinalizeCardPair(cardPair2Data []byte) error
	ReceivePhonons(phononTransfer []byte) error
	GenerateInvoice() (invoiceData []byte, err error)
	ReceiveInvoice(invoiceData []byte) error
	VerifyPaired() error
	PairingStatus() RemotePairingStatus
	ConnectToCard(string) error
}

type CurrencyType uint16

type CurveType uint8

type Denomination struct {
	Base     uint8
	Exponent uint8
}

type ECCPubKey struct {
	PubKey *ecdsa.PublicKey
}

type NativePubKey struct {
	Hash []byte
}

type Phonon struct {
	KeyIndex              uint16
	PubKey                PhononPubKey
	CurveType             CurveType
	SchemaVersion         uint8
	ExtendedSchemaVersion uint8
	Denomination          Denomination
	CurrencyType          CurrencyType
	ChainID               int
	ExtendedTLV           tlv.TLVList
	Address               string //chain specific attribute not stored on card
	AddressType           uint8  //chain specific address type identifier
}

type PhononCard interface {
	Select() (instanceUID []byte, cardPubKey *ecdsa.PublicKey, cardInitialized bool, err error)
	Pair() (*cert.CardCertificate, error)
	OpenSecureChannel() error
	OpenSecureConnection() error
	Init(pin string) error
	IdentifyCard(nonce []byte) (cardPubKey *ecdsa.PublicKey, cardSig *util.ECDSASignature, err error)
	VerifyPIN(pin string) error
	ChangePIN(pin string) error
	CreatePhonon(curveType CurveType) (keyIndex uint16, pubKey PhononPubKey, err error)
	SetDescriptor(phonon *Phonon) error
	ListPhonons(currencyType CurrencyType, lessThanValue uint64, greaterThanValue uint64, continuation bool) ([]*Phonon, error)
	GetPhononPubKey(keyIndex uint16, crv CurveType) (pubkey PhononPubKey, err error)
	DestroyPhonon(keyIndex uint16) (privKey *ecdsa.PrivateKey, err error)
	SendPhonons(keyIndices []uint16, extendedRequest bool) (transferPhononPackets []byte, err error)
	ReceivePhonons(phononTransfer []byte) error
	SetReceiveList(phononPubKeys []*ecdsa.PublicKey) error
	TransactionAck(keyIndices []uint16) error
	InitCardPairing(receiverCertificate cert.CardCertificate) (initPairingData []byte, err error)
	CardPair(initPairingData []byte) (cardPairData []byte, err error)
	CardPair2(cardPairData []byte) (cardPair2Data []byte, err error)
	FinalizeCardPair(cardPair2Data []byte) (err error)
	InstallCertificate(signKeyFunc func([]byte) ([]byte, error)) (err error)
	GenerateInvoice() (invoiceData []byte, err error)
	ReceiveInvoice(invoiceData []byte) (err error)
	SetFriendlyName(name string) error
	GetFriendlyName() (string, error)
	GetAvailableMemory() (persistentMem int, onResetMem int, onDeselectMem int, err error)
	MineNativePhonon(difficulty uint8) (keyIndex uint16, hash []byte, err error)
}

type PhononJSON struct {
	KeyIndex              uint16
	PubKey                string //pubkey as hexstring
	Address               string //Chain specific address as hexstring
	AddressType           uint8
	SchemaVersion         uint8
	ExtendedSchemaVersion uint8
	Denomination          Denomination
	CurrencyType          int
	ChainID               int
	CurveType             uint8
}

type PhononPubKey interface {
	Decode([]byte) (PhononPubKey, error)
	String() string
	Bytes() []byte
	Equal(PhononPubKey) bool
}

type RemotePairingStatus int

type RequestCardPair1 struct {
	Ret     chan ResponseCardPair1
	Payload []byte
}

type RequestCertificate struct {
	Ret chan ResponseCertificate
}

type RequestFinalizeCardPair struct {
	Ret     chan ResponseFinalizeCardPair
	Payload []byte
}

type RequestGetName struct {
	Ret chan ResponseGetName
}

type RequestIdentifyCard struct {
	Ret   chan ResponseIdentifyCard
	Nonce []byte
}

type RequestPairWithRemote struct {
	Ret  chan ResponsePairWithRemote
	Card CounterpartyPhononCard
}

type RequestReceivePhonons struct {
	Ret     chan ResponseReceivePhonons
	Payload []byte
}

type RequestSetPaired struct {
	Ret    chan ResponseSetPaired
	Status bool
}

type RequestSetRemote struct {
	Ret  chan ResponseSetRemote
	Card CounterpartyPhononCard
}

type ResponseCardPair1 struct {
	Err     error
	Payload []byte
}

type ResponseCertificate struct {
	Err     error
	Payload *cert.CardCertificate
}

type ResponseFinalizeCardPair struct {
	Err error
}

type ResponseGetName struct {
	Err  error
	Name string
}

type ResponseIdentifyCard struct {
	PubKey *ecdsa.PublicKey
	Sig    *util.ECDSASignature
	Err    error
}

type ResponsePairWithRemote struct {
	Err error
}

type ResponseReceivePhonons struct {
	Err error
}

type ResponseSetPaired struct {
	Err error
}

type ResponseSetRemote struct {
	Err error
}

type SessionRequest interface {
	GetName() string
}