2019-09-04 13:45:03 -07:00
|
|
|
package main
|
2019-09-03 07:22:41 -07:00
|
|
|
|
2019-09-04 14:15:18 -07:00
|
|
|
// #cgo CFLAGS: -I ../include -D LD_LIBRARY_PATH=../target/release
|
|
|
|
// #cgo LDFLAGS: -L ../target/release/ -lbolt
|
2019-09-03 07:22:41 -07:00
|
|
|
// #include <libbolt.h>
|
|
|
|
import "C"
|
2019-09-04 13:45:03 -07:00
|
|
|
import (
|
|
|
|
"encoding/json"
|
|
|
|
"strings"
|
|
|
|
)
|
2019-09-03 07:22:41 -07:00
|
|
|
|
2019-09-04 13:45:03 -07:00
|
|
|
type setupResp struct {
|
2019-10-11 09:55:30 -07:00
|
|
|
ChannelState string `json:"channel_state"`
|
|
|
|
ChannelToken string `json:"channel_token"`
|
|
|
|
CustState string `json:"cust_state"`
|
|
|
|
MerchState string `json:"merch_state"`
|
|
|
|
Com string `json:"com"`
|
|
|
|
ComProof string `json:"com_proof"`
|
|
|
|
IsTokenValid bool `json:"is_token_valid,string"`
|
|
|
|
IsEstablished bool `json:"is_established,string"`
|
|
|
|
IsPayValid bool `json:"is_pay_valid,string"`
|
|
|
|
Payment string `json:"payment"`
|
|
|
|
CloseToken string `json:"close_token"`
|
|
|
|
SenderCloseToken string `json:"sender_close_token"`
|
|
|
|
ReceiverCondCloseToken string `json:"receiver_cond_close_token"`
|
|
|
|
RevokeToken string `json:"revoke_token"`
|
|
|
|
PayToken string `json:"pay_token"`
|
|
|
|
SenderPayToken string `json:"sender_pay_token"`
|
|
|
|
ReceiverPayToken string `json:"receiver_pay_token"`
|
|
|
|
CustClose string `json:"cust_close"`
|
|
|
|
MerchClose string `json:"merch_close"`
|
|
|
|
Wpk string `json:"wpk"`
|
|
|
|
Error string `json:"error"`
|
|
|
|
Result string `json:"result"`
|
2019-09-04 13:45:03 -07:00
|
|
|
}
|
|
|
|
|
2019-09-13 07:52:55 -07:00
|
|
|
type ChannelState struct {
|
2019-10-11 10:42:02 -07:00
|
|
|
R int `json:"R"`
|
|
|
|
TxFee int64 `json:"tx_fee"`
|
|
|
|
Cp *ChannelParams `json:"cp"`
|
|
|
|
Name string `json:"name"`
|
|
|
|
PayInit bool `json:"pay_init"`
|
|
|
|
ChannelEstablished bool `json:"channel_established"`
|
|
|
|
ThirdParty bool `json:"third_party"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type ChannelParams struct {
|
|
|
|
ExtraVerify bool `json:"extra_verify"`
|
|
|
|
L int64 `json:"l"`
|
|
|
|
PubParams PubParams `json:"pub_params"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type PubParams struct {
|
|
|
|
ComParams ComParams `json:"comParams"`
|
|
|
|
Mpk MPK `json:"mpk"`
|
|
|
|
Pk PublicKey `json:"pk"`
|
|
|
|
RpParams RpPubParams `json:"rpParams"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type RpPubParams struct {
|
|
|
|
ComParams ComParams `json:"csParams"`
|
|
|
|
L int64 `json:"l"`
|
|
|
|
U int64 `json:"u"`
|
|
|
|
Mpk MPK `json:"mpk"`
|
|
|
|
Pk PublicKey `json:"pk"`
|
|
|
|
Signatures map[string]Signature `json:"signatures"`
|
2019-09-13 07:52:55 -07:00
|
|
|
}
|
|
|
|
|
2019-09-06 16:05:50 -07:00
|
|
|
type MerchState struct {
|
2019-10-11 10:42:02 -07:00
|
|
|
Id string `json:"id"`
|
|
|
|
KeyPair KeyPair `json:"keypair"`
|
|
|
|
NizkParams NIZKParams `json:"nizkParams"`
|
|
|
|
Pk string `json:"pk"`
|
|
|
|
Sk string `json:"sk"`
|
|
|
|
ComParams ComParams `json:"comParams"`
|
|
|
|
Keys map[string]RevokedKey `json:"keys"`
|
|
|
|
PayTokens map[string]Signature `json:"pay_tokens"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type RevokedKey struct {
|
|
|
|
Wpk string `json:"wpk"`
|
|
|
|
RevokeToken *string `json:"revoke_token"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type NIZKParams struct {
|
|
|
|
PubParams PubParams `json:"pubParams"`
|
|
|
|
KeyPair KeyPair `json:"keypair"`
|
|
|
|
RpParams RpParams `json:"rpParams"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type RpParams struct {
|
|
|
|
PubParams RpPubParams `json:"pubParams"`
|
|
|
|
KeyPair KeyPair `json:"kp"`
|
2019-09-06 16:05:50 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
type CustState struct {
|
|
|
|
Name string `json:"name"`
|
|
|
|
PkC string `json:"pk_c"`
|
|
|
|
SkC string `json:"sk_c"`
|
2019-10-11 09:55:30 -07:00
|
|
|
CustBalance int64 `json:"cust_balance"`
|
|
|
|
MerchBalance int64 `json:"merch_balance"`
|
2019-09-06 16:05:50 -07:00
|
|
|
Wpk string `json:"wpk"`
|
|
|
|
Wsk string `json:"wsk"`
|
|
|
|
OldKP *KP `json:"old_kp,omitempty"`
|
2019-09-16 09:21:00 -07:00
|
|
|
T []string `json:"t"`
|
2019-09-06 16:05:50 -07:00
|
|
|
Wallet Wallet `json:"wallet"`
|
|
|
|
WCom Commitment `json:"w_com"`
|
|
|
|
Index int `json:"index"`
|
|
|
|
CloseTokens map[string]Signature `json:"close_tokens"`
|
|
|
|
PayTokens map[string]Signature `json:"pay_tokens"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type KP struct {
|
|
|
|
Wpk string `json:"wpk,omitempty"`
|
|
|
|
Wsk string `json:"wsk,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type Commitment struct {
|
|
|
|
C string `json:"c"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type Wallet struct {
|
2019-09-16 09:21:00 -07:00
|
|
|
Pkc []string `json:"pkc"`
|
|
|
|
Wpk []string `json:"wpk"`
|
2019-10-11 09:55:30 -07:00
|
|
|
Bc int64 `json:"bc"`
|
|
|
|
Bm int64 `json:"bm"`
|
2019-09-16 09:21:00 -07:00
|
|
|
Close []string `json:"close"`
|
2019-09-06 16:05:50 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
type KeyPair struct {
|
|
|
|
Secret SecretKey `json:"secret"`
|
|
|
|
Public PublicKey `json:"public"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type SecretKey struct {
|
2019-09-16 09:21:00 -07:00
|
|
|
X []string `json:"x"`
|
|
|
|
Y [][]string `json:"y"`
|
2019-09-06 16:05:50 -07:00
|
|
|
}
|
|
|
|
|
2019-10-11 09:55:30 -07:00
|
|
|
type Payment struct {
|
|
|
|
Proof Proof `json:"proof"`
|
|
|
|
Com Commitment `json:"com"`
|
|
|
|
Wpk string `json:"wpk"`
|
|
|
|
Amount int64 `json:"amount"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type Proof struct {
|
|
|
|
Sig Signature `json:"sig"`
|
2019-10-11 10:42:02 -07:00
|
|
|
SigProof SigProof `json:"sigProof"`
|
2019-10-11 09:55:30 -07:00
|
|
|
ComProof CommitmentProof `json:"comProof"`
|
2019-10-11 10:42:02 -07:00
|
|
|
RangeProofBC RangeProof `json:"rpBC"`
|
|
|
|
RangeProofBM RangeProof `json:"rpBM"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type SigProof struct {
|
|
|
|
Zsig [][]string `json:"zsig"`
|
|
|
|
Zv []string `json:"zv"`
|
|
|
|
A interface{} `json:"a"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type RangeProof struct {
|
|
|
|
V []Signature `json:"V"`
|
|
|
|
D string `json:"D"`
|
|
|
|
Com Commitment `json:"comm"`
|
|
|
|
SigProofs []SigProof `json:"sigProofs"`
|
|
|
|
Zr []string `json:"zr"`
|
|
|
|
Zs [][]string `json:"zs"`
|
2019-10-11 09:55:30 -07:00
|
|
|
}
|
|
|
|
|
2019-09-06 16:05:50 -07:00
|
|
|
type PublicKey struct {
|
|
|
|
X1 string `json:"X1"`
|
|
|
|
X2 string `json:"X2"`
|
|
|
|
Y1 []string `json:"Y1"`
|
|
|
|
Y2 []string `json:"Y2"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type PublicKeySingle struct {
|
|
|
|
X string `json:"X"`
|
|
|
|
Y []string `json:"Y"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type ComParams struct {
|
|
|
|
PubBases []string `json:"pub_bases"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type Signature struct {
|
|
|
|
H1 string `json:"h"`
|
|
|
|
H2 string `json:"H"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type ChannelToken struct {
|
|
|
|
Pkc *string `json:"pk_c"`
|
|
|
|
Pkm string `json:"pk_m"`
|
|
|
|
ClPkM PublicKeySingle `json:"cl_pk_m"`
|
|
|
|
Mpk MPK `json:"mpk"`
|
|
|
|
ComParams ComParams `json:"comParams"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type MPK struct {
|
|
|
|
G1 string `json:"g1"`
|
|
|
|
G2 string `json:"g2"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type RevokeToken struct {
|
|
|
|
Message Message `json:"message"`
|
|
|
|
Signature string `json:"signature"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type Message struct {
|
|
|
|
Type string `json:"msgtype"`
|
|
|
|
Wpk string `json:"wpk"`
|
|
|
|
}
|
|
|
|
|
|
|
|
type CommitmentProof struct {
|
|
|
|
T string `json:"T"`
|
2019-09-16 09:21:00 -07:00
|
|
|
Z [][]string `json:"z"`
|
|
|
|
Ts [][]string `json:"t"`
|
2019-09-06 16:05:50 -07:00
|
|
|
Index []int `json:"index"`
|
2019-09-16 09:21:00 -07:00
|
|
|
Reveal [][]string `json:"reveal"`
|
2019-09-06 16:05:50 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
type CustClose struct {
|
|
|
|
Wpk string `json:"wpk"`
|
|
|
|
Message Wallet `json:"message"`
|
|
|
|
Signature Signature `json:"signature"`
|
|
|
|
}
|
|
|
|
|
2019-09-13 07:52:55 -07:00
|
|
|
func BidirectionalChannelSetup(name string, channelSupport bool) (ChannelState, error) {
|
2019-09-04 13:45:03 -07:00
|
|
|
resp := C.GoString(C.ffishim_bidirectional_channel_setup(C.CString(name), C.uint(btoi(channelSupport))))
|
2019-09-06 16:25:23 -07:00
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
2019-09-13 07:52:55 -07:00
|
|
|
return ChannelState{}, err
|
2019-09-06 16:25:23 -07:00
|
|
|
}
|
2019-09-13 07:52:55 -07:00
|
|
|
channelState := ChannelState{}
|
|
|
|
err = json.Unmarshal([]byte(r.ChannelState), &channelState)
|
|
|
|
return channelState, err
|
2019-09-04 13:45:03 -07:00
|
|
|
}
|
|
|
|
|
2019-09-16 08:58:10 -07:00
|
|
|
func BidirectionalInitMerchant(channelState ChannelState, nameMerchant string) (ChannelToken, MerchState, ChannelState, error) {
|
2019-09-13 07:52:55 -07:00
|
|
|
serChannelState, err := json.Marshal(channelState)
|
|
|
|
if err != nil {
|
|
|
|
return ChannelToken{}, MerchState{}, ChannelState{}, err
|
|
|
|
}
|
2019-09-16 08:58:10 -07:00
|
|
|
resp := C.GoString(C.ffishim_bidirectional_init_merchant(C.CString(string(serChannelState)), C.CString(nameMerchant)))
|
2019-09-06 16:25:23 -07:00
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
2019-09-13 07:52:55 -07:00
|
|
|
return ChannelToken{}, MerchState{}, ChannelState{}, err
|
2019-09-06 16:25:23 -07:00
|
|
|
}
|
2019-09-06 16:05:50 -07:00
|
|
|
merchState := MerchState{}
|
2019-09-06 16:25:23 -07:00
|
|
|
err = json.Unmarshal([]byte(r.MerchState), &merchState)
|
|
|
|
if err != nil {
|
2019-09-13 07:52:55 -07:00
|
|
|
return ChannelToken{}, MerchState{}, ChannelState{}, err
|
|
|
|
}
|
|
|
|
err = json.Unmarshal([]byte(r.ChannelState), &channelState)
|
|
|
|
if err != nil {
|
|
|
|
return ChannelToken{}, MerchState{}, ChannelState{}, err
|
2019-09-06 16:25:23 -07:00
|
|
|
}
|
2019-09-06 16:05:50 -07:00
|
|
|
channelToken := ChannelToken{}
|
2019-09-06 16:25:23 -07:00
|
|
|
err = json.Unmarshal([]byte(r.ChannelToken), &channelToken)
|
2019-09-13 07:52:55 -07:00
|
|
|
return channelToken, merchState, channelState, err
|
2019-09-04 13:45:03 -07:00
|
|
|
}
|
|
|
|
|
2019-09-16 08:58:10 -07:00
|
|
|
func BidirectionalInitCustomer(channelToken ChannelToken, balanceCustomer int, balanceMerchant int, nameCustomer string) (ChannelToken, CustState, error) {
|
2019-09-06 16:25:23 -07:00
|
|
|
serChannelToken, err := json.Marshal(channelToken)
|
|
|
|
if err != nil {
|
|
|
|
return ChannelToken{}, CustState{}, err
|
|
|
|
}
|
2019-09-27 10:02:31 -07:00
|
|
|
resp := C.GoString(C.ffishim_bidirectional_init_customer(C.CString(string(serChannelToken)), C.longlong(balanceCustomer), C.longlong(balanceMerchant), C.CString(nameCustomer)))
|
2019-09-06 16:25:23 -07:00
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
|
|
|
return ChannelToken{}, CustState{}, err
|
|
|
|
}
|
2019-09-06 16:05:50 -07:00
|
|
|
custState := CustState{}
|
2019-09-06 16:25:23 -07:00
|
|
|
err = json.Unmarshal([]byte(r.CustState), &custState)
|
|
|
|
if err != nil {
|
|
|
|
return ChannelToken{}, CustState{}, err
|
|
|
|
}
|
|
|
|
err = json.Unmarshal([]byte(r.ChannelToken), &channelToken)
|
|
|
|
return channelToken, custState, err
|
2019-09-04 13:45:03 -07:00
|
|
|
}
|
|
|
|
|
2019-09-06 16:25:23 -07:00
|
|
|
func BidirectionalEstablishCustomerGenerateProof(channelToken ChannelToken, custState CustState) (ChannelToken, CustState, Commitment, CommitmentProof, error) {
|
|
|
|
serChannelToken, err := json.Marshal(channelToken)
|
|
|
|
if err != nil {
|
|
|
|
return ChannelToken{}, CustState{}, Commitment{}, CommitmentProof{}, err
|
|
|
|
}
|
|
|
|
serCustState, err := json.Marshal(custState)
|
|
|
|
if err != nil {
|
|
|
|
return ChannelToken{}, CustState{}, Commitment{}, CommitmentProof{}, err
|
|
|
|
}
|
2019-09-06 16:05:50 -07:00
|
|
|
resp := C.GoString(C.ffishim_bidirectional_establish_customer_generate_proof(C.CString(string(serChannelToken)), C.CString(string(serCustState))))
|
2019-09-06 16:25:23 -07:00
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
|
|
|
return ChannelToken{}, CustState{}, Commitment{}, CommitmentProof{}, err
|
|
|
|
}
|
|
|
|
err = json.Unmarshal([]byte(r.CustState), &custState)
|
|
|
|
if err != nil {
|
|
|
|
return ChannelToken{}, CustState{}, Commitment{}, CommitmentProof{}, err
|
|
|
|
}
|
|
|
|
err = json.Unmarshal([]byte(r.ChannelToken), &channelToken)
|
|
|
|
if err != nil {
|
|
|
|
return ChannelToken{}, CustState{}, Commitment{}, CommitmentProof{}, err
|
|
|
|
}
|
2019-09-06 16:05:50 -07:00
|
|
|
com := Commitment{}
|
2019-09-06 16:25:23 -07:00
|
|
|
err = json.Unmarshal([]byte(r.Com), &com)
|
|
|
|
if err != nil {
|
|
|
|
return ChannelToken{}, CustState{}, Commitment{}, CommitmentProof{}, err
|
|
|
|
}
|
2019-09-06 16:05:50 -07:00
|
|
|
comProof := CommitmentProof{}
|
2019-09-06 16:25:23 -07:00
|
|
|
err = json.Unmarshal([]byte(r.ComProof), &comProof)
|
|
|
|
return channelToken, custState, com, comProof, err
|
2019-09-04 13:45:03 -07:00
|
|
|
}
|
|
|
|
|
2019-09-13 13:16:35 -07:00
|
|
|
func BidirectionalEstablishMerchantIssueCloseToken(channelState ChannelState, com Commitment, comProof CommitmentProof, pkc string, initCustBal int, initMerchBal int, merchState MerchState) (Signature, error) {
|
2019-09-13 07:52:55 -07:00
|
|
|
serChannelState, err := json.Marshal(channelState)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, err
|
|
|
|
}
|
2019-09-06 16:25:23 -07:00
|
|
|
serCom, err := json.Marshal(com)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, err
|
|
|
|
}
|
|
|
|
serMerchState, err := json.Marshal(merchState)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, err
|
|
|
|
}
|
|
|
|
serComProof, err := json.Marshal(comProof)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, err
|
|
|
|
}
|
2019-09-27 10:02:31 -07:00
|
|
|
resp := C.GoString(C.ffishim_bidirectional_establish_merchant_issue_close_token(C.CString(string(serChannelState)), C.CString(string(serCom)), C.CString(string(serComProof)), C.CString(pkc), C.longlong(initCustBal), C.longlong(initMerchBal), C.CString(string(serMerchState))))
|
2019-09-06 16:25:23 -07:00
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, err
|
|
|
|
}
|
|
|
|
closeToken := Signature{}
|
|
|
|
err = json.Unmarshal([]byte(r.CloseToken), &closeToken)
|
|
|
|
return closeToken, err
|
2019-09-04 13:45:03 -07:00
|
|
|
}
|
|
|
|
|
2019-09-13 07:52:55 -07:00
|
|
|
func BidirectionalEstablishMerchantIssuePayToken(channelState ChannelState, com Commitment, merchState MerchState) (Signature, error) {
|
|
|
|
serChannelState, err := json.Marshal(channelState)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, err
|
|
|
|
}
|
2019-09-06 16:25:23 -07:00
|
|
|
serCom, err := json.Marshal(com)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, err
|
|
|
|
}
|
|
|
|
serMerchState, err := json.Marshal(merchState)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, err
|
|
|
|
}
|
2019-09-13 07:52:55 -07:00
|
|
|
resp := C.GoString(C.ffishim_bidirectional_establish_merchant_issue_pay_token(C.CString(string(serChannelState)), C.CString(string(serCom)), C.CString(string(serMerchState))))
|
2019-09-06 16:25:23 -07:00
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, err
|
|
|
|
}
|
|
|
|
payToken := Signature{}
|
|
|
|
err = json.Unmarshal([]byte(r.PayToken), &payToken)
|
|
|
|
return payToken, err
|
2019-09-04 13:45:03 -07:00
|
|
|
}
|
|
|
|
|
2019-09-13 07:52:55 -07:00
|
|
|
func BidirectionalVerifyCloseToken(channelState ChannelState, custState CustState, closeToken Signature) (bool, ChannelState, CustState, error) {
|
|
|
|
serChannelState, err := json.Marshal(channelState)
|
|
|
|
if err != nil {
|
|
|
|
return false, ChannelState{}, CustState{}, err
|
|
|
|
}
|
2019-09-06 16:25:23 -07:00
|
|
|
serCloseToken, err := json.Marshal(closeToken)
|
|
|
|
if err != nil {
|
2019-09-13 07:52:55 -07:00
|
|
|
return false, ChannelState{}, CustState{}, err
|
2019-09-06 16:25:23 -07:00
|
|
|
}
|
|
|
|
serCustState, err := json.Marshal(custState)
|
|
|
|
if err != nil {
|
2019-09-13 07:52:55 -07:00
|
|
|
return false, ChannelState{}, CustState{}, err
|
2019-09-06 16:25:23 -07:00
|
|
|
}
|
2019-09-13 07:52:55 -07:00
|
|
|
resp := C.GoString(C.ffishim_bidirectional_verify_close_token(C.CString(string(serChannelState)), C.CString(string(serCustState)), C.CString(string(serCloseToken))))
|
2019-09-06 16:25:23 -07:00
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
2019-09-13 07:52:55 -07:00
|
|
|
return false, ChannelState{}, CustState{}, err
|
|
|
|
}
|
|
|
|
err = json.Unmarshal([]byte(r.ChannelState), &channelState)
|
|
|
|
if err != nil {
|
|
|
|
return false, ChannelState{}, CustState{}, err
|
2019-09-06 16:25:23 -07:00
|
|
|
}
|
|
|
|
err = json.Unmarshal([]byte(r.CustState), &custState)
|
2019-09-13 07:52:55 -07:00
|
|
|
return r.IsTokenValid, channelState, custState, err
|
2019-09-04 13:45:03 -07:00
|
|
|
}
|
|
|
|
|
2019-09-13 07:52:55 -07:00
|
|
|
func BidirectionalEstablishCustomerFinal(channelState ChannelState, custState CustState, payToken Signature) (bool, ChannelState, CustState, error) {
|
|
|
|
serChannelState, err := json.Marshal(channelState)
|
|
|
|
if err != nil {
|
|
|
|
return false, ChannelState{}, CustState{}, err
|
|
|
|
}
|
2019-09-06 16:25:23 -07:00
|
|
|
serPayToken, err := json.Marshal(payToken)
|
|
|
|
if err != nil {
|
2019-09-13 07:52:55 -07:00
|
|
|
return false, ChannelState{}, CustState{}, err
|
2019-09-06 16:25:23 -07:00
|
|
|
}
|
|
|
|
serCustState, err := json.Marshal(custState)
|
|
|
|
if err != nil {
|
2019-09-13 07:52:55 -07:00
|
|
|
return false, ChannelState{}, CustState{}, err
|
2019-09-06 16:25:23 -07:00
|
|
|
}
|
2019-09-13 07:52:55 -07:00
|
|
|
resp := C.GoString(C.ffishim_bidirectional_establish_customer_final(C.CString(string(serChannelState)), C.CString(string(serCustState)), C.CString(string(serPayToken))))
|
2019-09-06 16:25:23 -07:00
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
2019-10-11 09:55:30 -07:00
|
|
|
return false, ChannelState{}, CustState{}, err
|
2019-09-13 07:52:55 -07:00
|
|
|
}
|
|
|
|
err = json.Unmarshal([]byte(r.ChannelState), &channelState)
|
|
|
|
if err != nil {
|
|
|
|
return false, ChannelState{}, CustState{}, err
|
2019-09-06 16:25:23 -07:00
|
|
|
}
|
|
|
|
err = json.Unmarshal([]byte(r.CustState), &custState)
|
2019-09-13 07:52:55 -07:00
|
|
|
return r.IsEstablished, channelState, custState, err
|
2019-09-04 13:45:03 -07:00
|
|
|
}
|
|
|
|
|
2019-10-11 09:55:30 -07:00
|
|
|
func BidirectionalPayGeneratePaymentProof(channelState ChannelState, custState CustState, amount int) (Payment, CustState, error) {
|
2019-09-13 07:52:55 -07:00
|
|
|
serChannelState, err := json.Marshal(channelState)
|
|
|
|
if err != nil {
|
2019-10-11 09:55:30 -07:00
|
|
|
return Payment{}, CustState{}, err
|
2019-09-13 07:52:55 -07:00
|
|
|
}
|
2019-09-06 16:25:23 -07:00
|
|
|
serCustState, err := json.Marshal(custState)
|
|
|
|
if err != nil {
|
2019-10-11 09:55:30 -07:00
|
|
|
return Payment{}, CustState{}, err
|
2019-09-06 16:25:23 -07:00
|
|
|
}
|
2019-09-27 10:02:31 -07:00
|
|
|
resp := C.GoString(C.ffishim_bidirectional_pay_generate_payment_proof(C.CString(string(serChannelState)), C.CString(string(serCustState)), C.longlong(amount)))
|
2019-09-06 16:25:23 -07:00
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
2019-10-11 09:55:30 -07:00
|
|
|
return Payment{}, CustState{}, err
|
|
|
|
}
|
|
|
|
payProof := Payment{}
|
|
|
|
err = json.Unmarshal([]byte(r.Payment), &payProof)
|
|
|
|
if err != nil {
|
|
|
|
return Payment{}, CustState{}, err
|
2019-09-06 16:25:23 -07:00
|
|
|
}
|
|
|
|
err = json.Unmarshal([]byte(r.CustState), &custState)
|
2019-10-11 09:55:30 -07:00
|
|
|
return payProof, custState, err
|
2019-09-04 14:12:11 -07:00
|
|
|
}
|
|
|
|
|
2019-10-11 09:55:30 -07:00
|
|
|
func BidirectionalPayVerifyPaymentProof(channelState ChannelState, payProof Payment, merchState MerchState) (Signature, MerchState, error) {
|
2019-09-13 07:52:55 -07:00
|
|
|
serChannelState, err := json.Marshal(channelState)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, MerchState{}, err
|
|
|
|
}
|
2019-10-11 09:55:30 -07:00
|
|
|
serPayProof, err := json.Marshal(payProof)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, MerchState{}, err
|
|
|
|
}
|
2019-09-06 16:25:23 -07:00
|
|
|
serMerchState, err := json.Marshal(merchState)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, MerchState{}, err
|
|
|
|
}
|
2019-10-11 09:55:30 -07:00
|
|
|
resp := C.GoString(C.ffishim_bidirectional_pay_verify_payment_proof(C.CString(string(serChannelState)), C.CString(string(serPayProof)), C.CString(string(serMerchState))))
|
2019-09-06 16:25:23 -07:00
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, MerchState{}, err
|
|
|
|
}
|
|
|
|
err = json.Unmarshal([]byte(r.MerchState), &merchState)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, MerchState{}, err
|
|
|
|
}
|
2019-09-06 16:05:50 -07:00
|
|
|
closeToken := &Signature{}
|
2019-09-06 16:25:23 -07:00
|
|
|
err = json.Unmarshal([]byte(r.CloseToken), closeToken)
|
|
|
|
return *closeToken, merchState, err
|
2019-09-04 14:12:11 -07:00
|
|
|
}
|
|
|
|
|
2019-10-11 09:55:30 -07:00
|
|
|
func BidirectionalPayVerifyMultiplePaymentProofs(channelState ChannelState, senderPayProof Payment, receiverPayProof Payment, merchState MerchState) (Signature, Signature, MerchState, error) {
|
|
|
|
serChannelState, err := json.Marshal(channelState)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, Signature{}, MerchState{}, err
|
|
|
|
}
|
|
|
|
serSenderPayProof, err := json.Marshal(senderPayProof)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, Signature{}, MerchState{}, err
|
|
|
|
}
|
|
|
|
serReceiverPayProof, err := json.Marshal(receiverPayProof)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, Signature{}, MerchState{}, err
|
|
|
|
}
|
|
|
|
serMerchState, err := json.Marshal(merchState)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, Signature{}, MerchState{}, err
|
|
|
|
}
|
|
|
|
resp := C.GoString(C.ffishim_bidirectional_pay_verify_multiple_payment_proofs(C.CString(string(serChannelState)), C.CString(string(serSenderPayProof)), C.CString(string(serReceiverPayProof)), C.CString(string(serMerchState))))
|
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, Signature{}, MerchState{}, err
|
|
|
|
}
|
|
|
|
err = json.Unmarshal([]byte(r.MerchState), &merchState)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, Signature{}, MerchState{}, err
|
|
|
|
}
|
|
|
|
senderCloseToken := &Signature{}
|
|
|
|
err = json.Unmarshal([]byte(r.SenderCloseToken), senderCloseToken)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, Signature{}, MerchState{}, err
|
|
|
|
}
|
|
|
|
receiverCondCloseToken := &Signature{}
|
|
|
|
err = json.Unmarshal([]byte(r.ReceiverCondCloseToken), receiverCondCloseToken)
|
|
|
|
return *senderCloseToken, *receiverCondCloseToken, merchState, err
|
|
|
|
}
|
|
|
|
|
2019-09-13 07:52:55 -07:00
|
|
|
func BidirectionalPayGenerateRevokeToken(channelState ChannelState, custState CustState, newCustState CustState, closeToken Signature) (RevokeToken, CustState, error) {
|
|
|
|
serChannelState, err := json.Marshal(channelState)
|
|
|
|
if err != nil {
|
|
|
|
return RevokeToken{}, CustState{}, err
|
|
|
|
}
|
2019-09-06 16:25:23 -07:00
|
|
|
serCloseToken, err := json.Marshal(closeToken)
|
|
|
|
if err != nil {
|
|
|
|
return RevokeToken{}, CustState{}, err
|
|
|
|
}
|
|
|
|
serCustState, err := json.Marshal(custState)
|
|
|
|
if err != nil {
|
|
|
|
return RevokeToken{}, CustState{}, err
|
|
|
|
}
|
|
|
|
serNewCustState, err := json.Marshal(newCustState)
|
|
|
|
if err != nil {
|
|
|
|
return RevokeToken{}, CustState{}, err
|
|
|
|
}
|
2019-09-13 07:52:55 -07:00
|
|
|
resp := C.GoString(C.ffishim_bidirectional_pay_generate_revoke_token(C.CString(string(serChannelState)), C.CString(string(serCustState)), C.CString(string(serNewCustState)), C.CString(string(serCloseToken))))
|
2019-09-06 16:25:23 -07:00
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
|
|
|
return RevokeToken{}, CustState{}, err
|
|
|
|
}
|
|
|
|
err = json.Unmarshal([]byte(r.CustState), &custState)
|
|
|
|
if err != nil {
|
|
|
|
return RevokeToken{}, CustState{}, err
|
|
|
|
}
|
2019-09-06 16:05:50 -07:00
|
|
|
revokeToken := RevokeToken{}
|
2019-09-06 16:25:23 -07:00
|
|
|
err = json.Unmarshal([]byte(r.RevokeToken), &revokeToken)
|
|
|
|
return revokeToken, custState, err
|
2019-09-04 14:12:11 -07:00
|
|
|
}
|
|
|
|
|
2019-09-06 16:25:23 -07:00
|
|
|
func BidirectionalPayVerifyRevokeToken(revokeToken RevokeToken, merchState MerchState) (Signature, MerchState, error) {
|
|
|
|
serMerchState, err := json.Marshal(merchState)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, MerchState{}, err
|
|
|
|
}
|
|
|
|
serRevokeToken, err := json.Marshal(revokeToken)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, MerchState{}, err
|
|
|
|
}
|
2019-09-06 16:05:50 -07:00
|
|
|
resp := C.GoString(C.ffishim_bidirectional_pay_verify_revoke_token(C.CString(string(serRevokeToken)), C.CString(string(serMerchState))))
|
2019-09-06 16:25:23 -07:00
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, MerchState{}, err
|
|
|
|
}
|
|
|
|
err = json.Unmarshal([]byte(r.MerchState), &merchState)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, MerchState{}, err
|
|
|
|
}
|
2019-09-06 16:05:50 -07:00
|
|
|
payToken := &Signature{}
|
2019-09-06 16:25:23 -07:00
|
|
|
err = json.Unmarshal([]byte(r.PayToken), payToken)
|
|
|
|
return *payToken, merchState, err
|
2019-09-04 14:12:11 -07:00
|
|
|
}
|
|
|
|
|
2019-10-11 09:55:30 -07:00
|
|
|
func BidirectionalPayVerifyMultipleRevokeTokens(senderRevokeToken RevokeToken, receiverRevokeToken RevokeToken, merchState MerchState) (Signature, Signature, MerchState, error) {
|
|
|
|
serMerchState, err := json.Marshal(merchState)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, Signature{}, MerchState{}, err
|
|
|
|
}
|
|
|
|
serSenderRevokeToken, err := json.Marshal(senderRevokeToken)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, Signature{}, MerchState{}, err
|
|
|
|
}
|
|
|
|
serReceiverRevokeToken, err := json.Marshal(receiverRevokeToken)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, Signature{}, MerchState{}, err
|
|
|
|
}
|
|
|
|
resp := C.GoString(C.ffishim_bidirectional_pay_verify_multiple_revoke_tokens(C.CString(string(serSenderRevokeToken)), C.CString(string(serReceiverRevokeToken)), C.CString(string(serMerchState))))
|
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, Signature{}, MerchState{}, err
|
|
|
|
}
|
|
|
|
err = json.Unmarshal([]byte(r.MerchState), &merchState)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, Signature{}, MerchState{}, err
|
|
|
|
}
|
|
|
|
senderPayToken := &Signature{}
|
|
|
|
err = json.Unmarshal([]byte(r.SenderPayToken), senderPayToken)
|
|
|
|
if err != nil {
|
|
|
|
return Signature{}, Signature{}, MerchState{}, err
|
|
|
|
}
|
|
|
|
receiverPayToken := &Signature{}
|
|
|
|
err = json.Unmarshal([]byte(r.ReceiverPayToken), receiverPayToken)
|
|
|
|
return *senderPayToken, *receiverPayToken, merchState, err
|
|
|
|
}
|
|
|
|
|
2019-09-13 07:52:55 -07:00
|
|
|
func BidirectionalPayVerifyPaymentToken(channelState ChannelState, custState CustState, payToken Signature) (CustState, bool, error) {
|
|
|
|
serChannelState, err := json.Marshal(channelState)
|
|
|
|
if err != nil {
|
|
|
|
return CustState{}, false, err
|
|
|
|
}
|
2019-09-06 16:25:23 -07:00
|
|
|
serPayToken, err := json.Marshal(payToken)
|
|
|
|
if err != nil {
|
|
|
|
return CustState{}, false, err
|
|
|
|
}
|
|
|
|
serCustState, err := json.Marshal(custState)
|
|
|
|
if err != nil {
|
|
|
|
return CustState{}, false, err
|
|
|
|
}
|
2019-09-13 07:52:55 -07:00
|
|
|
resp := C.GoString(C.ffishim_bidirectional_pay_verify_payment_token(C.CString(string(serChannelState)), C.CString(string(serCustState)), C.CString(string(serPayToken))))
|
2019-09-06 16:25:23 -07:00
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
|
|
|
return CustState{}, false, err
|
|
|
|
}
|
|
|
|
err = json.Unmarshal([]byte(r.CustState), &custState)
|
|
|
|
return custState, r.IsPayValid, err
|
2019-09-04 14:12:11 -07:00
|
|
|
}
|
|
|
|
|
2019-09-13 07:52:55 -07:00
|
|
|
func BidirectionalCustomerClose(channelState ChannelState, custState CustState) (CustClose, error) {
|
|
|
|
serChannelState, err := json.Marshal(channelState)
|
|
|
|
if err != nil {
|
|
|
|
return CustClose{}, err
|
|
|
|
}
|
2019-09-06 16:25:23 -07:00
|
|
|
serCustState, err := json.Marshal(custState)
|
|
|
|
if err != nil {
|
|
|
|
return CustClose{}, err
|
|
|
|
}
|
2019-09-13 07:52:55 -07:00
|
|
|
resp := C.GoString(C.ffishim_bidirectional_customer_close(C.CString(string(serChannelState)), C.CString(string(serCustState))))
|
2019-09-06 16:25:23 -07:00
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
|
|
|
return CustClose{}, err
|
|
|
|
}
|
|
|
|
custClose := CustClose{}
|
|
|
|
err = json.Unmarshal([]byte(r.CustClose), &custClose)
|
|
|
|
return custClose, err
|
2019-09-04 14:12:11 -07:00
|
|
|
}
|
|
|
|
|
2019-09-13 07:52:55 -07:00
|
|
|
func BidirectionalMerchantClose(channelState ChannelState, channelToken ChannelToken, serAddress string, custClose CustClose, merchState MerchState) (string, string, string, error) {
|
|
|
|
serChannelState, err := json.Marshal(channelState)
|
|
|
|
if err != nil {
|
|
|
|
return "", "", "", err
|
|
|
|
}
|
2019-09-06 16:25:23 -07:00
|
|
|
serMerchState, err := json.Marshal(merchState)
|
|
|
|
if err != nil {
|
|
|
|
return "", "", "", err
|
|
|
|
}
|
|
|
|
serChannelToken, err := json.Marshal(channelToken)
|
|
|
|
if err != nil {
|
|
|
|
return "", "", "", err
|
|
|
|
}
|
|
|
|
serCustClose, err := json.Marshal(custClose)
|
|
|
|
if err != nil {
|
|
|
|
return "", "", "", err
|
|
|
|
}
|
2019-09-13 07:52:55 -07:00
|
|
|
resp := C.GoString(C.ffishim_bidirectional_merchant_close(C.CString(string(serChannelState)), C.CString(string(serChannelToken)), C.CString(serAddress), C.CString(string(serCustClose)), C.CString(string(serMerchState))))
|
2019-09-06 16:25:23 -07:00
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
|
|
|
return "", "", "", err
|
|
|
|
}
|
|
|
|
return r.Wpk, r.MerchClose, r.Error, nil
|
2019-09-04 14:12:11 -07:00
|
|
|
}
|
|
|
|
|
2019-09-06 16:25:23 -07:00
|
|
|
func BidirectionalWtpVerifyCustCloseMessage(channelToken ChannelToken, serWpk string, serCloseMsg string, serCloseToken string) (string, error) {
|
|
|
|
serChannelToken, err := json.Marshal(channelToken)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
2019-09-06 16:05:50 -07:00
|
|
|
resp := C.GoString(C.ffishim_bidirectional_wtp_verify_cust_close_message(C.CString(string(serChannelToken)), C.CString(serWpk), C.CString(serCloseMsg), C.CString(string(serCloseToken))))
|
2019-09-06 16:25:23 -07:00
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
return r.Result, nil
|
2019-09-04 14:12:11 -07:00
|
|
|
}
|
|
|
|
|
2019-09-06 16:25:23 -07:00
|
|
|
func BidirectionalWtpVerifyMerchCloseMessage(channelToken ChannelToken, serWpk string, serMerchClose string) (string, error) {
|
|
|
|
serChannelToken, err := json.Marshal(channelToken)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
2019-09-06 16:05:50 -07:00
|
|
|
resp := C.GoString(C.ffishim_bidirectional_wtp_verify_merch_close_message(C.CString(string(serChannelToken)), C.CString(serWpk), C.CString(serMerchClose)))
|
2019-09-06 16:25:23 -07:00
|
|
|
r, err := processCResponse(resp)
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
return r.Result, nil
|
2019-09-04 14:12:11 -07:00
|
|
|
}
|
|
|
|
|
2019-09-06 16:25:23 -07:00
|
|
|
func processCResponse(resp string) (*setupResp, error) {
|
2019-09-04 13:45:03 -07:00
|
|
|
resp = cleanJson(resp)
|
|
|
|
r := &setupResp{}
|
2019-09-06 16:25:23 -07:00
|
|
|
err := json.Unmarshal([]byte(resp), r)
|
|
|
|
return r, err
|
2019-09-04 13:45:03 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
func cleanJson(in string) string {
|
|
|
|
resp := strings.ReplaceAll(in, "\"", "\\\"")
|
|
|
|
resp = strings.ReplaceAll(resp, "'", "\"")
|
|
|
|
return resp
|
|
|
|
}
|
|
|
|
|
|
|
|
func btoi(b bool) int {
|
|
|
|
if b {
|
|
|
|
return 1
|
|
|
|
}
|
|
|
|
return 0
|
2019-09-03 07:58:05 -07:00
|
|
|
}
|