crypto

type AlgebraicSys interface {
	Marshaller
	GetModule() *big.Int
	Name() string
	NewScalar() FieldElement //fr
	//NewField() FieldElement  //fp
	PutScalar(FieldElement)
	GetRootOfUnity(uint64) (FieldElement, uint64, error)
}

type CA interface {
	GetHostName() string
	GetKeyIdentifier() []byte
	//GetPubKeyForPairing 返回key，用于和ca的私钥配对（典型值为65字节），仅在分布式CA中调用
	GetPubKeyForPairing() []byte
	String() string
}

type Cert interface {
	GetCertType() CertType
	GetHostName() string
	GetCAHostName() string
	GetExtName() map[string]string
	GetAuthorityKeyIdentifier() []byte
	String() string
	GetVerifyKey() VerifyKey
	VerifyCert(caList []string) error
}

type CertType int

type ChainSDK interface {
	//ChainType 返回链的类型
	ChainType() string
	//InvokeFinish 调用Finish方法, namespace是分区（通道），address是合约地址（名称）
	InvokeFinish(nodes []string, address, taskID, proof, result, error string) ([]byte, error)
	//RegisterListening 注册监听EVENT_FINISH和EVENT_COMPUTE事件
	RegisterListening(proxyAddress, businessAddress []string) (chan *Event, error)
	//UnregisterListening 解注册事件
	UnregisterListening(address string) error
}

type ChainType string

type Cryptor interface {
	Encryptor
	Decryptor
}

type DecKey interface {
	EncKey
	Decrypt(cipher []byte) ([]byte, error)
	Destroy()
}

type Decryptor interface {
	// Decrypt decrypts ciphertext using key k.
	Decrypt(k, cipherText []byte) (plaintext []byte, err error)
}

type EncKey interface {
	GetKeyInfo() int
	Encrypt(msg []byte, reader io.Reader) ([]byte, error)
	//Bytes for more information, see  comment of VerifyKey.Bytes
	Bytes() []byte
}

type Encryptor interface {
	// Encrypt encrypts plaintext using key k.
	Encrypt(k, plaintext []byte, reader io.Reader) (cipherText []byte, err error)
}

type Event struct {
	ChannelID string    `json:"channelID"`
	Type      EventType `json:"type"`
	Event     []byte    `json:"event"` //json content
	TxHash    string    `json:"txHash"`
	BlockNum  int       `json:"blockNum"`
}

type EventCompute struct {
	TaskID                 string   `json:"taskID"`
	CircuitID              [32]byte `json:"circuitID"`
	CCName                 string   `json:"ccName"`
	WebHook                string   `json:"webHook"`
	WebHookBodyPattern     string   `json:"webHookBodyPattern"`
	BusinessContractAddr   string   `json:"businessContractAddr"`
	BusinessContractMethod string   `json:"businessContractMethod"`
	Input                  string   `json:"input"`
}

type EventFinish struct {
	TaskID      string   `json:"taskID"`
	CircuitID   [32]byte `json:"circuitID"`
	Proof       string   `json:"proof"`
	Result      string   `json:"result"`
	Error       string   `json:"error"`
	Response    []byte   `json:"response"`
	NextCompute []byte   `json:"nextCompute"`
}

type EventType int

type FieldElement interface {
	UnmarshalJSON([]byte) error
	MarshalJSON() ([]byte, error)
	Add(a1, a2 FieldElement) FieldElement
	Double(FieldElement) FieldElement
	Sub(a1, a2 FieldElement) FieldElement
	Neg(FieldElement) FieldElement
	Mul(a1, a2 FieldElement) FieldElement
	Square(FieldElement) FieldElement
	Div(a1, a2 FieldElement) FieldElement
	Inv(FieldElement) FieldElement
	Exp(FieldElement, []byte) FieldElement

	Equal(FieldElement) bool
	IsZero() bool
	IsOne() bool
	IsNeg() bool

	Set(FieldElement) FieldElement
	SetOne() FieldElement
	SetZero() FieldElement
	SetInt64(int64) FieldElement
	SetUint64(uint64) FieldElement
	SetRandom(io.Reader) FieldElement

	// From sets self to v (regular form) and returns self (Montgomery form)
	From(rat *big.Int) FieldElement
	//Regular append regular bytes to 'in', keep 'z' unchanged
	Regular(in []byte) []byte
	//FromRegular interprets 'content' as the bytes of a big-endian unsigned integer,
	// sets z to that value (in Montgomery form), and returns z.
	FromRegular(content []byte) FieldElement

	//MontBytes set and return 'res' with bytes in Montgomery form
	MontBytes(res []byte) []byte

	//GetModule set 'b' to 21888242871839275222246405745257275088548364400416034343698204186575808495617
	GetModule(*big.Int)
	String() string
	//Copy get a clone
	Copy() FieldElement
}

type FlagReader interface {
	io.Reader
	GetFlag() int
}

type Hasher interface {
	hash.Hash
	// Hash hashes messages msg.
	Hash(msg []byte) (hash []byte, err error)
	// BatchHash If you need to hash a series of bytes slices, calling BachHash can reduce one copy. BenchHash implies a loop.
	// example: a,b,c,d are four big byte slice
	// BenchHash([][]bytes{a,b,c,d}) faster than Hash(bytes.Join([][]bytes{a,b,c,d},nil))
	// It reduce one join(...). Join implies one copy.
	BatchHash(msg [][]byte) (hash []byte, err error)
}

type Key interface {
	// Bytes converts this key to its byte representation,
	// if this operation is allowed.
	Bytes() ([]byte, error)

	//FromBytes It's revert method to Bytes()
	//K is a byte that needs to be parsed, and the meaning of opt depend on Keys, for example, it's maybe an algorithm type. If the parsing fails, return empty Key or nil.
	FromBytes(k []byte, opt int) error
}

type Level interface {
	//GetLevel the second return value is reserved and has NO effect at present!
	GetLevel() ([]int, uint8)
}

type Logger interface {
	Debug(v ...interface{})
	Debugf(format string, v ...interface{})
	Info(v ...interface{})
	Infof(format string, v ...interface{})
	Notice(v ...interface{})
	Noticef(format string, v ...interface{})
	Warning(v ...interface{})
	Warningf(format string, v ...interface{})
	Error(v ...interface{})
	Errorf(format string, v ...interface{})
	Critical(v ...interface{})
	Criticalf(format string, v ...interface{})
}

type MPC interface {
	New(curve string, power uint) []byte
	Contribute(entropy, name string) error
	Verify() (bool, error)
	Beacon(string, int) error
	GetPower() int
	GetG1() []Point
	GetG2() []Point
	GetPairing() string
	GetHash() string
	VerifyWithHistory(srsBefore MPC) (bool, error)
	Marshaller
}

type Marshaller interface {
	Marshal() []byte
	Unmarshal([]byte) ([]byte, error)
}

type NewSDKFunc func(path, user, namespace string, logger Logger) (ChainSDK, error)

type Pairing interface {
	AlgebraicSys
	Pair([]Point, []Point) Point
	PairCheck(P []Point, Q []Point) bool
	IsOnCurve(Point) error
	//GetBase never change result's value for GetBase, GetModule and GetOlder!
	GetBase(Position) Point
	NewPoint(Position) Point
	BatchScalarMultiplicationG1(scalars []*big.Int, ret []Point)
	BatchScalarMultiplicationG2(scalars []*big.Int, ret []Point)
}

type PluginCryptFunc interface {
	Level
	GetSecretKey(mode int, pwd, key []byte) (SecretKey, error)
}

type PluginGenerateSessionKeyFunc interface {
	Level
	KeyAgreementInit(curve elliptic.Curve) (data1, data2ToPeer []byte, err error)
	KeyAgreementFinal(curve elliptic.Curve, algo string, data1, data2FromPeer []byte) (SecretKey, error)
}

type PluginHashFunc interface {
	Level
	GetHash(mode int) (Hasher, error)
}

type PluginRandomFunc interface {
	Level
	Rander() (io.Reader, error)
}

type PluginSignFuncL0 interface {
	Level
	//GetVerifyKey enter a raw publicKey and mod, return a VerifyKey
	//a raw publicKey means:
	// 1) for sm2, key is 65bytes and in 0x04||X||Y form, see GMT0009-2012 7.1
	//      http://www.gmbz.org.cn/main/viewfile/2018011001400692565.html may help
	// 2) for ecdsa, key is in 0x04||X||Y. The length depends on the curve, for example,
	//		65 bytes for secp256k1 and 133 for secp521r1, see 2.3.3 in [SEC1] uncompressed form.
	//		https://www.rfc-editor.org/rfc/rfc5480.txt may help
	GetVerifyKey(key []byte, mode int) (VerifyKey, error)
}

type PluginSignFuncL1 interface {
	PluginSignFuncL0
	//GetSignKey parse printable keyIndex to SignKey
	GetSignKey(keyIndex string) (SignKey, error)
}

type PluginSignFuncL2 interface {
	PluginSignFuncL1
	//CreateSignKey generate a sign key
	CreateSignKey() (index string, k SignKey, err error)
	//ParseCertificate for x509, input is PEM or self-defined TXT
	ParseCertificate(string) (Cert, error)
	//ParseAllCA parse ca
	ParseAllCA([]string) ([]CA, error)
}

type PluginSignFuncL3 interface {
	PluginSignFuncL2
	//Issue ext for NVP and LP: key is pkix.Platform, pkix.Version, pkix.VP
	Issue(ca CA, hostname string, ct CertType, ext map[string]string, vk VerifyKey) ([]byte, error)
	GenerateLocalCA(hostName string) (skIndex string, ca CA, err error)
}

type Point interface {
	Marshaller
	Add(Point, Point) Point
	Set(Point) Point
	Double(Point) Point
	//Neg neg
	Neg(Point) Point
	ScalarMult(Point, *big.Int) Point //scalar is at Z+
	ScalarBaseMult(*big.Int) Point
	//GetPosition get position
	GetPosition() Position
	GetPairing() Pairing
	SetInfinity()
	IsInfinity() bool
}

type Position int

type PrivateKey interface {
	SignKey
	DecKey
}

type ProveKey interface {
	Prove(cs R1CS, witness []FieldElement, mpc MPC) ([]byte, error)
	GetSnark() string
	GetPairing() string
	GetVKTag() string
	Marshaller
}

type ProverInfo map[string][]*big.Int

type PublicKey interface {
	VerifyKey
	EncKey
}

type R1CS interface {
	fmt.Stringer
	R1CSIterator
	SignalNum() int //m
	InputNum() (privateInput, publicInput int)
	OutputNum() int // l = publicInput + OutputNum() + 1 = m - privateInput
	Marshal() []byte
	GetPairing() Pairing
}

type R1CSIterator interface {
	ConstraintsNum() uint64
	Next(pos *int) (index int, a, b, c map[int]FieldElement)
	GetSignalByID(nowid int) (id, reoffset int, prefix string, value FieldElement)
}

type Response struct {
	Continue bool `json:"continue"`
	//NextParam: proxyContractAddr, input, businessContractAddr, businessContractMethod, WebHook and WebHookBodyPattern
	NextParam [6]string `json:"nextParam"`
	//response
	Response []byte `json:"response"`
}

type SecretKey interface {
	Encrypt(src []byte, reader io.Reader) []byte
	Decrypt(src []byte) []byte
	Destroy()
}

type SignKey interface {
	VerifyKey
	Sign(msg []byte, hasher hash.Hash, rand io.Reader) ([]byte, error)
	Destroy()
}

type Signer interface {
	Key
	Sign(k, digest []byte, reader io.Reader) ([]byte, error)
}

type Snarks interface {
	Name() string
	Setup(r1cs R1CS) (ProveKey, VerifyProofKey, error)
	GenCode(p, v []byte, circuitID [32]byte, t ChainType) []byte
	UnmarshalVK(in []byte) (VerifyProofKey, error)
	UnmarshalPK(in []byte) (ProveKey, error)
}

type VCMetrics interface {
	UpdateGetDataTime(s, e int64)
	UpdateWaitTime(s, e int64)
	UpdateProveTime(s, e int64)
	UpdateVerifyTime(s, e int64)
	UpdateComputerTime(s, e int64)
	UpdateG1TPS(s, e int64, n int)
	UpdateG2TPS(s, e int64, n int)
}

type Verifier interface {
	Key
	// Verify verifies signature against key k and digest
	Verify(k, signature, digest []byte) (valid bool, err error)
}

type VerifyKey interface {
	GetKeyInfo() int
	Verify(msg []byte, hasher hash.Hash, sig []byte) bool
	//Bytes return a raw key bytes without algorithm information
	//sm2: SM2PublicKey::=BIT STRING,	04||X||Y,	65 Bytes,	GMT0009-2012 7.1
	//ecdsa: PublicKeyBytes in PKIX publicKey
	//rsa: asn1{N, e}
	//matching public and private key pairs need to return the same result
	Bytes() []byte
	//RichBytes return a bytes with algorithm information
	RichBytes() []byte
}

type VerifyProofKey interface {
	Verify(in []byte, limit string, mpc MPC) error
	GetSnark() string
	GetPairing() string
	Marshaller
}