transfer

type Proof struct {
	// proof that inputs and outputs in a Transfer Action are well-formed
	// inputs and outputs have the same total value
	// inputs and outputs have the same type
	WellFormedness []byte
	// Proof that the outputs have value in the authorized range
	RangeCorrectness []byte
}

type Prover struct {
	WellFormedness   *WellFormednessProver
	RangeCorrectness *rangeproof.Prover
}

type Sender struct {
	// Signers is an array of Signer that matches the owners of the inputs
	// to be spent in the transfer action
	Signers []driver.Signer
	// Inputs to be spent in the transfer
	Inputs []*token.Token
	// InputIDs is the identifiers of the Inputs to be spent
	InputIDs []string
	// contains the opening of the inputs to be spent
	InputInformation []*token.Metadata
	// PublicParams refers to the public cryptographic parameters to be used
	// to produce the TokenRequest
	PublicParams *crypto.PublicParams
}

type SigningIdentity interface {
	driver.SigningIdentity
}

type TransferAction struct {
	// Inputs specify the identifiers in of the tokens to be spent
	Inputs []string
	// InputCommitments are the PedersenCommitments in the inputs
	InputCommitments []*math.G1
	// OutputTokens are the new tokens resulting from the transfer
	OutputTokens []*token.Token
	// ZK Proof that shows that the transfer is correct
	Proof []byte
	// Metadata contains the transfer action's metadata
	Metadata map[string][]byte
}

type Verifier struct {
	WellFormedness   *WellFormednessVerifier
	RangeCorrectness *rangeproof.Verifier
}

type WellFormedness struct {
	// proof of knowledge of the randomness used in Pedersen commitments in the inputs
	InputBlindingFactors []*math.Zr
	// proof of knowledge of the randomness used in Pedersen commitments in the outputs
	OutputBlindingFactors []*math.Zr
	// proof of knowledge of the values encoded in the Pedersen commitments in the inputs
	InputValues []*math.Zr
	// proof of knowledge of the values encoded in the Pedersen commitments in the outputs
	OutputValues []*math.Zr
	// proof of knowledge of the token type encoded in both inputs and outputs
	Type *math.Zr
	// proof of knowledge of the sum of inputs and the sum of outputs
	// sum of inputs equal sum of outputs
	Sum *math.Zr
	// challenge used in proof
	Challenge *math.Zr
}

type WellFormednessCommitments struct {
	Inputs    []*math.G1
	Outputs   []*math.G1
	InputSum  *math.G1
	OutputSum *math.G1
}

type WellFormednessProver struct {
	*WellFormednessVerifier
	// contains filtered or unexported fields
}

type WellFormednessRandomness struct {
	Type *math.Zr
	// contains filtered or unexported fields
}

type WellFormednessVerifier struct {
	// PedParams corresponds to the generators used to compute Pedersen commitments
	// (g_1, g_2, h)
	PedParams []*math.G1
	// Curve is the elliptic curve in which Pedersen commitments are computed
	Curve *math.Curve
	// Inputs are Pedersen commitments to (Type, Value) of the inputs to be spent
	Inputs []*math.G1
	// Outputs are Pedersen commitments to (Type, Value) of the outputs to be created
	// after the transfer
	Outputs []*math.G1
}

type WellFormednessWitness struct {

	// Type is the token type of inputs and outputs
	Type string
	// contains filtered or unexported fields
}