go: error handling

go/libbolt.go

@@ -142,172 +142,328 @@ type CustClose struct {
 	Signature Signature `json:"signature"`
 }
 
-func BidirectionalChannelSetup(name string, channelSupport bool) string {
+func BidirectionalChannelSetup(name string, channelSupport bool) (string, error) {
 	resp := C.GoString(C.ffishim_bidirectional_channel_setup(C.CString(name), C.uint(btoi(channelSupport))))
-	r := processCResponse(resp)
+	r, err := processCResponse(resp)
-	return r.ChannelState
+	if err != nil {
+		return "", err
+	}
+	return r.ChannelState, nil
 }
 
-func BidirectionalInitMerchant(channelState string, balanceMerchant int, nameMerchant string) (ChannelToken, MerchState) {
+func BidirectionalInitMerchant(channelState string, balanceMerchant int, nameMerchant string) (ChannelToken, MerchState, error) {
 	resp := C.GoString(C.ffishim_bidirectional_init_merchant(C.CString(channelState), C.int(balanceMerchant), C.CString(nameMerchant)))
-	r := processCResponse(resp)
+	r, err := processCResponse(resp)
+	if err != nil {
+		return ChannelToken{}, MerchState{}, err
+	}
 	merchState := MerchState{}
-	json.Unmarshal([]byte(r.MerchState), &merchState)
+	err = json.Unmarshal([]byte(r.MerchState), &merchState)
+	if err != nil {
+		return ChannelToken{}, MerchState{}, err
+	}
 	channelToken := ChannelToken{}
-	json.Unmarshal([]byte(r.ChannelToken), &channelToken)
+	err = json.Unmarshal([]byte(r.ChannelToken), &channelToken)
-	return channelToken, merchState
+	return channelToken, merchState, err
 }
 
-func BidirectionalInitCustomer(channelState string, channelToken ChannelToken, balanceCustomer int, balanceMerchant int, nameCustomer string) (ChannelToken, CustState) {
+func BidirectionalInitCustomer(channelState string, channelToken ChannelToken, balanceCustomer int, balanceMerchant int, nameCustomer string) (ChannelToken, CustState, error) {
-	serChannelToken, _ := json.Marshal(channelToken)
+	serChannelToken, err := json.Marshal(channelToken)
+	if err != nil {
+		return ChannelToken{}, CustState{}, err
+	}
 	resp := C.GoString(C.ffishim_bidirectional_init_customer(C.CString(channelState), C.CString(string(serChannelToken)), C.int(balanceCustomer), C.int(balanceMerchant), C.CString(nameCustomer)))
-	r := processCResponse(resp)
+	r, err := processCResponse(resp)
+	if err != nil {
+		return ChannelToken{}, CustState{}, err
+	}
 	custState := CustState{}
-	json.Unmarshal([]byte(r.CustState), &custState)
+	err = json.Unmarshal([]byte(r.CustState), &custState)
-	json.Unmarshal([]byte(r.ChannelToken), &channelToken)
+	if err != nil {
-	return channelToken, custState
+		return ChannelToken{}, CustState{}, err
+	}
+	err = json.Unmarshal([]byte(r.ChannelToken), &channelToken)
+	return channelToken, custState, err
 }
 
-func BidirectionalEstablishCustomerGenerateProof(channelToken ChannelToken, custState CustState) (ChannelToken, CustState, Commitment, CommitmentProof) {
+func BidirectionalEstablishCustomerGenerateProof(channelToken ChannelToken, custState CustState) (ChannelToken, CustState, Commitment, CommitmentProof, error) {
-	serChannelToken, _ := json.Marshal(channelToken)
+	serChannelToken, err := json.Marshal(channelToken)
-	serCustState, _ := json.Marshal(custState)
+	if err != nil {
+		return ChannelToken{}, CustState{}, Commitment{}, CommitmentProof{}, err
+	}
+	serCustState, err := json.Marshal(custState)
+	if err != nil {
+		return ChannelToken{}, CustState{}, Commitment{}, CommitmentProof{}, err
+	}
 	resp := C.GoString(C.ffishim_bidirectional_establish_customer_generate_proof(C.CString(string(serChannelToken)), C.CString(string(serCustState))))
-	r := processCResponse(resp)
+	r, err := processCResponse(resp)
-	json.Unmarshal([]byte(r.CustState), &custState)
+	if err != nil {
-	json.Unmarshal([]byte(r.ChannelToken), &channelToken)
+		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
+	}
 	com := Commitment{}
-	json.Unmarshal([]byte(r.Com), &com)
+	err = json.Unmarshal([]byte(r.Com), &com)
+	if err != nil {
+		return ChannelToken{}, CustState{}, Commitment{}, CommitmentProof{}, err
+	}
 	comProof := CommitmentProof{}
-	json.Unmarshal([]byte(r.ComProof), &comProof)
+	err = json.Unmarshal([]byte(r.ComProof), &comProof)
-	return channelToken, custState, com, comProof
+	return channelToken, custState, com, comProof, err
 }
 
-func BidirectionalEstablishMerchantIssueCloseToken(serChannelState string, com Commitment, comProof CommitmentProof, initCustBal int, initMerchBal int, merchState MerchState) Signature {
+func BidirectionalEstablishMerchantIssueCloseToken(serChannelState string, com Commitment, comProof CommitmentProof, initCustBal int, initMerchBal int, merchState MerchState) (Signature, error) {
-	serCom, _ := json.Marshal(com)
+	serCom, err := json.Marshal(com)
-	serMerchState, _ := json.Marshal(merchState)
+	if err != nil {
-	serComProof, _ := json.Marshal(comProof)
+		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
+	}
 	resp := C.GoString(C.ffishim_bidirectional_establish_merchant_issue_close_token(C.CString(serChannelState), C.CString(string(serCom)), C.CString(string(serComProof)), C.int(initCustBal), C.int(initMerchBal), C.CString(string(serMerchState))))
-	r := processCResponse(resp)
+	r, err := processCResponse(resp)
-	closeToken := &Signature{}
+	if err != nil {
-	json.Unmarshal([]byte(r.CloseToken), closeToken)
+		return Signature{}, err
-	return *closeToken
+	}
+	closeToken := Signature{}
+	err = json.Unmarshal([]byte(r.CloseToken), &closeToken)
+	return closeToken, err
 }
 
-func BidirectionalEstablishMerchantIssuePayToken(serChannelState string, com Commitment, merchState MerchState) Signature {
+func BidirectionalEstablishMerchantIssuePayToken(serChannelState string, com Commitment, merchState MerchState) (Signature, error) {
-	serCom, _ := json.Marshal(com)
+	serCom, err := json.Marshal(com)
-	serMerchState, _ := json.Marshal(merchState)
+	if err != nil {
+		return Signature{}, err
+	}
+	serMerchState, err := json.Marshal(merchState)
+	if err != nil {
+		return Signature{}, err
+	}
 	resp := C.GoString(C.ffishim_bidirectional_establish_merchant_issue_pay_token(C.CString(serChannelState), C.CString(string(serCom)), C.CString(string(serMerchState))))
-	r := processCResponse(resp)
+	r, err := processCResponse(resp)
-	payToken := &Signature{}
+	if err != nil {
-	json.Unmarshal([]byte(r.PayToken), payToken)
+		return Signature{}, err
-	return *payToken
+	}
+	payToken := Signature{}
+	err = json.Unmarshal([]byte(r.PayToken), &payToken)
+	return payToken, err
 }
 
-func BidirectionalVerifyCloseToken(serChannelState string, custState CustState, closeToken Signature) (bool, string, CustState) {
+func BidirectionalVerifyCloseToken(serChannelState string, custState CustState, closeToken Signature) (bool, string, CustState, error) {
-	serCloseToken, _ := json.Marshal(closeToken)
+	serCloseToken, err := json.Marshal(closeToken)
-	serCustState, _ := json.Marshal(custState)
+	if err != nil {
+		return false, "", CustState{}, err
+	}
+	serCustState, err := json.Marshal(custState)
+	if err != nil {
+		return false, "", CustState{}, err
+	}
 	resp := C.GoString(C.ffishim_bidirectional_verify_close_token(C.CString(serChannelState), C.CString(string(serCustState)), C.CString(string(serCloseToken))))
-	r := processCResponse(resp)
+	r, err := processCResponse(resp)
-	json.Unmarshal([]byte(r.CustState), &custState)
+	if err != nil {
-	return r.IsTokenValid, r.ChannelState, custState
+		return false, "", CustState{}, err
+	}
+	err = json.Unmarshal([]byte(r.CustState), &custState)
+	return r.IsTokenValid, r.ChannelState, custState, err
 }
 
-func BidirectionalEstablishCustomerFinal(serChannelState string, custState CustState, payToken Signature) (bool, string, CustState) {
+func BidirectionalEstablishCustomerFinal(serChannelState string, custState CustState, payToken Signature) (bool, string, CustState, error) {
-	serPayToken, _ := json.Marshal(payToken)
+	serPayToken, err := json.Marshal(payToken)
-	serCustState, _ := json.Marshal(custState)
+	if err != nil {
+		return false, "", CustState{}, err
+	}
+	serCustState, err := json.Marshal(custState)
+	if err != nil {
+		return false, "", CustState{}, err
+	}
 	resp := C.GoString(C.ffishim_bidirectional_establish_customer_final(C.CString(serChannelState), C.CString(string(serCustState)), C.CString(string(serPayToken))))
-	r := processCResponse(resp)
+	r, err := processCResponse(resp)
-	json.Unmarshal([]byte(r.CustState), &custState)
+	if err != nil {
-	return r.IsEstablished, r.ChannelState, custState
+		return false, "", CustState{}, err
+	}
+	err = json.Unmarshal([]byte(r.CustState), &custState)
+	return r.IsEstablished, r.ChannelState, custState, err
 }
 
-func BidirectionalPayGeneratePaymentProof(serChannelState string, custState CustState, amount int) (string, CustState) {
+func BidirectionalPayGeneratePaymentProof(serChannelState string, custState CustState, amount int) (string, CustState, error) {
-	serCustState, _ := json.Marshal(custState)
+	serCustState, err := json.Marshal(custState)
+	if err != nil {
+		return "", CustState{}, err
+	}
 	resp := C.GoString(C.ffishim_bidirectional_pay_generate_payment_proof(C.CString(serChannelState), C.CString(string(serCustState)), C.int(amount)))
-	r := processCResponse(resp)
+	r, err := processCResponse(resp)
-	json.Unmarshal([]byte(r.CustState), &custState)
+	if err != nil {
-	return r.Payment, custState
+		return "", CustState{}, err
+	}
+	err = json.Unmarshal([]byte(r.CustState), &custState)
+	return r.Payment, custState, err
 }
 
-func BidirectionalPayVerifyPaymentProof(serChannelState string, serPayProof string, merchState MerchState) (Signature, MerchState) {
+func BidirectionalPayVerifyPaymentProof(serChannelState string, serPayProof string, merchState MerchState) (Signature, MerchState, error) {
-	serMerchState, _ := json.Marshal(merchState)
+	serMerchState, err := json.Marshal(merchState)
+	if err != nil {
+		return Signature{}, MerchState{}, err
+	}
 	resp := C.GoString(C.ffishim_bidirectional_pay_verify_payment_proof(C.CString(serChannelState), C.CString(serPayProof), C.CString(string(serMerchState))))
-	r := processCResponse(resp)
+	r, err := processCResponse(resp)
-	json.Unmarshal([]byte(r.MerchState), &merchState)
+	if err != nil {
+		return Signature{}, MerchState{}, err
+	}
+	err = json.Unmarshal([]byte(r.MerchState), &merchState)
+	if err != nil {
+		return Signature{}, MerchState{}, err
+	}
 	closeToken := &Signature{}
-	json.Unmarshal([]byte(r.CloseToken), closeToken)
+	err = json.Unmarshal([]byte(r.CloseToken), closeToken)
-	return *closeToken, merchState
+	return *closeToken, merchState, err
 }
 
-func BidirectionalPayGenerateRevokeToken(serChannelState string, custState CustState, newCustState CustState, closeToken Signature) (RevokeToken, CustState) {
+func BidirectionalPayGenerateRevokeToken(serChannelState string, custState CustState, newCustState CustState, closeToken Signature) (RevokeToken, CustState, error) {
-	serCloseToken, _ := json.Marshal(closeToken)
+	serCloseToken, err := json.Marshal(closeToken)
-	serCustState, _ := json.Marshal(custState)
+	if err != nil {
-	serNewCustState, _ := json.Marshal(newCustState)
+		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
+	}
 	resp := C.GoString(C.ffishim_bidirectional_pay_generate_revoke_token(C.CString(serChannelState), C.CString(string(serCustState)), C.CString(string(serNewCustState)), C.CString(string(serCloseToken))))
-	r := processCResponse(resp)
+	r, err := processCResponse(resp)
-	json.Unmarshal([]byte(r.CustState), &custState)
+	if err != nil {
+		return RevokeToken{}, CustState{}, err
+	}
+	err = json.Unmarshal([]byte(r.CustState), &custState)
+	if err != nil {
+		return RevokeToken{}, CustState{}, err
+	}
 	revokeToken := RevokeToken{}
-	json.Unmarshal([]byte(r.RevokeToken), &revokeToken)
+	err = json.Unmarshal([]byte(r.RevokeToken), &revokeToken)
-	return revokeToken, custState
+	return revokeToken, custState, err
 }
 
-func BidirectionalPayVerifyRevokeToken(revokeToken RevokeToken, merchState MerchState) (Signature, MerchState) {
+func BidirectionalPayVerifyRevokeToken(revokeToken RevokeToken, merchState MerchState) (Signature, MerchState, error) {
-	serMerchState, _ := json.Marshal(merchState)
+	serMerchState, err := json.Marshal(merchState)
-	serRevokeToken, _ := json.Marshal(revokeToken)
+	if err != nil {
+		return Signature{}, MerchState{}, err
+	}
+	serRevokeToken, err := json.Marshal(revokeToken)
+	if err != nil {
+		return Signature{}, MerchState{}, err
+	}
 	resp := C.GoString(C.ffishim_bidirectional_pay_verify_revoke_token(C.CString(string(serRevokeToken)), C.CString(string(serMerchState))))
-	r := processCResponse(resp)
+	r, err := processCResponse(resp)
-	json.Unmarshal([]byte(r.MerchState), &merchState)
+	if err != nil {
+		return Signature{}, MerchState{}, err
+	}
+	err = json.Unmarshal([]byte(r.MerchState), &merchState)
+	if err != nil {
+		return Signature{}, MerchState{}, err
+	}
 	payToken := &Signature{}
-	json.Unmarshal([]byte(r.PayToken), payToken)
+	err = json.Unmarshal([]byte(r.PayToken), payToken)
-	return *payToken, merchState
+	return *payToken, merchState, err
 }
 
-func BidirectionalPayVerifyPaymentToken(serChannelState string, custState CustState, payToken Signature) (CustState, bool) {
+func BidirectionalPayVerifyPaymentToken(serChannelState string, custState CustState, payToken Signature) (CustState, bool, error) {
-	serPayToken, _ := json.Marshal(payToken)
+	serPayToken, err := json.Marshal(payToken)
-	serCustState, _ := json.Marshal(custState)
+	if err != nil {
+		return CustState{}, false, err
+	}
+	serCustState, err := json.Marshal(custState)
+	if err != nil {
+		return CustState{}, false, err
+	}
 	resp := C.GoString(C.ffishim_bidirectional_pay_verify_payment_token(C.CString(serChannelState), C.CString(string(serCustState)), C.CString(string(serPayToken))))
-	r := processCResponse(resp)
+	r, err := processCResponse(resp)
-	json.Unmarshal([]byte(r.CustState), &custState)
+	if err != nil {
-	return custState, r.IsPayValid
+		return CustState{}, false, err
+	}
+	err = json.Unmarshal([]byte(r.CustState), &custState)
+	return custState, r.IsPayValid, err
 }
 
-func BidirectionalCustomerClose(serChannelState string, custState CustState) CustClose {
+func BidirectionalCustomerClose(serChannelState string, custState CustState) (CustClose, error) {
-	serCustState, _ := json.Marshal(custState)
+	serCustState, err := json.Marshal(custState)
+	if err != nil {
+		return CustClose{}, err
+	}
 	resp := C.GoString(C.ffishim_bidirectional_customer_close(C.CString(serChannelState), C.CString(string(serCustState))))
-	r := processCResponse(resp)
+	r, err := processCResponse(resp)
-	custClose:= CustClose{}
+	if err != nil {
-	json.Unmarshal([]byte(r.CustClose), &custClose)
+		return CustClose{}, err
-	return custClose
+	}
+	custClose := CustClose{}
+	err = json.Unmarshal([]byte(r.CustClose), &custClose)
+	return custClose, err
 }
 
-func BidirectionalMerchantClose(serChannelState string, channelToken ChannelToken, serAddress string, custClose CustClose, merchState MerchState) (string, string, string) {
+func BidirectionalMerchantClose(serChannelState string, channelToken ChannelToken, serAddress string, custClose CustClose, merchState MerchState) (string, string, string, error) {
-	serMerchState, _ := json.Marshal(merchState)
+	serMerchState, err := json.Marshal(merchState)
-	serChannelToken, _ := json.Marshal(channelToken)
+	if err != nil {
-	serCustClose, _ := json.Marshal(custClose)
+		return "", "", "", err
+	}
+	serChannelToken, err := json.Marshal(channelToken)
+	if err != nil {
+		return "", "", "", err
+	}
+	serCustClose, err := json.Marshal(custClose)
+	if err != nil {
+		return "", "", "", err
+	}
 	resp := C.GoString(C.ffishim_bidirectional_merchant_close(C.CString(serChannelState), C.CString(string(serChannelToken)), C.CString(serAddress), C.CString(string(serCustClose)), C.CString(string(serMerchState))))
-	r := processCResponse(resp)
+	r, err := processCResponse(resp)
-	return r.Wpk, r.MerchClose, r.Error
+	if err != nil {
+		return "", "", "", err
+	}
+	return r.Wpk, r.MerchClose, r.Error, nil
 }
 
-func BidirectionalWtpVerifyCustCloseMessage(channelToken ChannelToken, serWpk string, serCloseMsg string, serCloseToken string) string {
+func BidirectionalWtpVerifyCustCloseMessage(channelToken ChannelToken, serWpk string, serCloseMsg string, serCloseToken string) (string, error) {
-	serChannelToken, _ := json.Marshal(channelToken)
+	serChannelToken, err := json.Marshal(channelToken)
+	if err != nil {
+		return "", err
+	}
 	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))))
-	r := processCResponse(resp)
+	r, err := processCResponse(resp)
-	return r.Result
+	if err != nil {
+		return "", err
+	}
+	return r.Result, nil
 }
 
-func BidirectionalWtpVerifyMerchCloseMessage(channelToken ChannelToken, serWpk string, serMerchClose string) string {
+func BidirectionalWtpVerifyMerchCloseMessage(channelToken ChannelToken, serWpk string, serMerchClose string) (string, error) {
-	serChannelToken, _ := json.Marshal(channelToken)
+	serChannelToken, err := json.Marshal(channelToken)
+	if err != nil {
+		return "", err
+	}
 	resp := C.GoString(C.ffishim_bidirectional_wtp_verify_merch_close_message(C.CString(string(serChannelToken)), C.CString(serWpk), C.CString(serMerchClose)))
-	r := processCResponse(resp)
+	r, err := processCResponse(resp)
-	return r.Result
+	if err != nil {
+		return "", err
+	}
+	return r.Result, nil
 }
 
-func processCResponse(resp string) *setupResp {
+func processCResponse(resp string) (*setupResp, error) {
 	resp = cleanJson(resp)
 	r := &setupResp{}
-	json.Unmarshal([]byte(resp), r)
+	err := json.Unmarshal([]byte(resp), r)
-	return r
+	return r, err
 }
 
 func cleanJson(in string) string {

go/libbolt_test.go

@@ -6,37 +6,50 @@ import (
 )
 
 func Test_ChannelSetup(t *testing.T) {
-	_, channelToken, merchState, custState := setup(1000, 100)
+	_, channelToken, merchState, custState, err := setup(1000, 100)
+	assert.Nil(t, err)
 
 	assert.NotEqual(t, "", merchState)
 	assert.NotEqual(t, "", custState)
 	assert.NotEqual(t, "", channelToken)
 }
 
-func setup(b0Cust int, b0Merch int) (string, ChannelToken, MerchState, CustState) {
+func setup(b0Cust int, b0Merch int) (string, ChannelToken, MerchState, CustState, error) {
-	channelState := BidirectionalChannelSetup("Test Channel", false)
+	channelState, err := BidirectionalChannelSetup("Test Channel", false)
-	channelToken, merchState := BidirectionalInitMerchant(channelState, b0Merch, "Bob")
+	if err != nil {
-	channelToken, custState := BidirectionalInitCustomer(channelState, channelToken, b0Cust, b0Merch, "Alice")
+		return "", ChannelToken{}, MerchState{}, CustState{}, err
-	return channelState, channelToken, merchState, custState
+	}
+	channelToken, merchState, err := BidirectionalInitMerchant(channelState, b0Merch, "Bob")
+	if err != nil {
+		return "", ChannelToken{}, MerchState{}, CustState{}, err
+	}
+	channelToken, custState, err := BidirectionalInitCustomer(channelState, channelToken, b0Cust, b0Merch, "Alice")
+	return channelState, channelToken, merchState, custState, err
 }
 
 func Test_Establish(t *testing.T) {
 	b0Cust := 1000
 	b0Merch := 100
-	channelState, channelToken, merchState, custState := setup(b0Cust, b0Merch)
+	channelState, channelToken, merchState, custState, err := setup(b0Cust, b0Merch)
+	assert.Nil(t, err)
 
-	channelToken, custState, com, comProof := BidirectionalEstablishCustomerGenerateProof(channelToken, custState)
+	channelToken, custState, com, comProof, err := BidirectionalEstablishCustomerGenerateProof(channelToken, custState)
+	assert.Nil(t, err)
 
-	closeToken := BidirectionalEstablishMerchantIssueCloseToken(channelState, com, comProof, b0Cust, b0Merch, merchState)
+	closeToken, err := BidirectionalEstablishMerchantIssueCloseToken(channelState, com, comProof, b0Cust, b0Merch, merchState)
+	assert.Nil(t, err)
 	assert.NotNil(t, closeToken)
 
-	isTokenValid, channelState, custState := BidirectionalVerifyCloseToken(channelState, custState, closeToken)
+	isTokenValid, channelState, custState, err := BidirectionalVerifyCloseToken(channelState, custState, closeToken)
+	assert.Nil(t, err)
 	assert.True(t, isTokenValid)
 
-	payToken := BidirectionalEstablishMerchantIssuePayToken(channelState, com, merchState)
+	payToken, err := BidirectionalEstablishMerchantIssuePayToken(channelState, com, merchState)
+	assert.Nil(t, err)
 	assert.NotNil(t, payToken)
 
-	isChannelEstablished, channelState, custState := BidirectionalEstablishCustomerFinal(channelState, custState, payToken)
+	isChannelEstablished, channelState, custState, err := BidirectionalEstablishCustomerFinal(channelState, custState, payToken)
+	assert.Nil(t, err)
 
 	assert.True(t, isChannelEstablished)
 }
@@ -44,39 +57,63 @@ func Test_Establish(t *testing.T) {
 func Test_Pay(t *testing.T) {
 	b0Cust := 1000
 	b0Merch := 100
-	channelState, channelToken, merchState, custState := setup(b0Cust, b0Merch)
+	channelState, channelToken, merchState, custState, err := setup(b0Cust, b0Merch)
-	channelToken, custState, com, comProof := BidirectionalEstablishCustomerGenerateProof(channelToken, custState)
+	assert.Nil(t, err)
-	closeToken := BidirectionalEstablishMerchantIssueCloseToken(channelState, com, comProof, b0Cust, b0Merch, merchState)
+	channelToken, custState, com, comProof, err := BidirectionalEstablishCustomerGenerateProof(channelToken, custState)
-	_, channelState, custState = BidirectionalVerifyCloseToken(channelState, custState, closeToken)
+	assert.Nil(t, err)
-	payToken := BidirectionalEstablishMerchantIssuePayToken(channelState, com, merchState)
+	closeToken, err := BidirectionalEstablishMerchantIssueCloseToken(channelState, com, comProof, b0Cust, b0Merch, merchState)
-	_, channelState, custState = BidirectionalEstablishCustomerFinal(channelState, custState, payToken)
+	assert.Nil(t, err)
+	_, channelState, custState, err = BidirectionalVerifyCloseToken(channelState, custState, closeToken)
+	assert.Nil(t, err)
+	payToken, err := BidirectionalEstablishMerchantIssuePayToken(channelState, com, merchState)
+	assert.Nil(t, err)
+	_, channelState, custState, err = BidirectionalEstablishCustomerFinal(channelState, custState, payToken)
+	assert.Nil(t, err)
 
-	payment, newCustState := BidirectionalPayGeneratePaymentProof(channelState, custState, 10)
+	payment, newCustState, err := BidirectionalPayGeneratePaymentProof(channelState, custState, 10)
-	closeToken, merchState = BidirectionalPayVerifyPaymentProof(channelState, payment, merchState)
+	assert.Nil(t, err)
-	revokeToken, custState := BidirectionalPayGenerateRevokeToken(channelState, custState, newCustState, closeToken)
+	closeToken, merchState, err = BidirectionalPayVerifyPaymentProof(channelState, payment, merchState)
-	payToken, merchState = BidirectionalPayVerifyRevokeToken(revokeToken, merchState)
+	assert.Nil(t, err)
-	custState, isTokenValid := BidirectionalPayVerifyPaymentToken(channelState, custState, payToken)
+	revokeToken, custState, err := BidirectionalPayGenerateRevokeToken(channelState, custState, newCustState, closeToken)
+	assert.Nil(t, err)
+	payToken, merchState, err = BidirectionalPayVerifyRevokeToken(revokeToken, merchState)
+	assert.Nil(t, err)
+	custState, isTokenValid, err := BidirectionalPayVerifyPaymentToken(channelState, custState, payToken)
+	assert.Nil(t, err)
 	assert.True(t, isTokenValid)
 }
 
 func Test_Close(t *testing.T) {
 	b0Cust := 1000
 	b0Merch := 100
-	channelState, channelToken, merchState, custState := setup(b0Cust, b0Merch)
+	channelState, channelToken, merchState, custState, err := setup(b0Cust, b0Merch)
-	channelToken, custState, com, comProof := BidirectionalEstablishCustomerGenerateProof(channelToken, custState)
+	assert.Nil(t, err)
-	closeToken := BidirectionalEstablishMerchantIssueCloseToken(channelState, com, comProof, b0Cust, b0Merch, merchState)
+	channelToken, custState, com, comProof, err := BidirectionalEstablishCustomerGenerateProof(channelToken, custState)
-	_, channelState, custState = BidirectionalVerifyCloseToken(channelState, custState, closeToken)
+	assert.Nil(t, err)
-	payToken := BidirectionalEstablishMerchantIssuePayToken(channelState, com, merchState)
+	closeToken, err := BidirectionalEstablishMerchantIssueCloseToken(channelState, com, comProof, b0Cust, b0Merch, merchState)
-	_, channelState, custState = BidirectionalEstablishCustomerFinal(channelState, custState, payToken)
+	assert.Nil(t, err)
+	_, channelState, custState, err = BidirectionalVerifyCloseToken(channelState, custState, closeToken)
+	assert.Nil(t, err)
+	payToken, err := BidirectionalEstablishMerchantIssuePayToken(channelState, com, merchState)
+	assert.Nil(t, err)
+	_, channelState, custState, err = BidirectionalEstablishCustomerFinal(channelState, custState, payToken)
+	assert.Nil(t, err)
 
-	payment, newCustState := BidirectionalPayGeneratePaymentProof(channelState, custState, 10)
+	payment, newCustState, err := BidirectionalPayGeneratePaymentProof(channelState, custState, 10)
-	closeToken, merchState = BidirectionalPayVerifyPaymentProof(channelState, payment, merchState)
+	assert.Nil(t, err)
-	revokeToken, custState := BidirectionalPayGenerateRevokeToken(channelState, custState, newCustState, closeToken)
+	closeToken, merchState, err = BidirectionalPayVerifyPaymentProof(channelState, payment, merchState)
-	payToken, merchState = BidirectionalPayVerifyRevokeToken(revokeToken, merchState)
+	assert.Nil(t, err)
-	custState, _ = BidirectionalPayVerifyPaymentToken(channelState, custState, payToken)
+	revokeToken, custState, err := BidirectionalPayGenerateRevokeToken(channelState, custState, newCustState, closeToken)
+	assert.Nil(t, err)
+	payToken, merchState, err = BidirectionalPayVerifyRevokeToken(revokeToken, merchState)
+	assert.Nil(t, err)
+	custState, _, err = BidirectionalPayVerifyPaymentToken(channelState, custState, payToken)
+	assert.Nil(t, err)
 
-	custClose := BidirectionalCustomerClose(channelState, custState)
+	custClose, err := BidirectionalCustomerClose(channelState, custState)
-	_, _, err := BidirectionalMerchantClose(channelState, channelToken, "onChainAddress", custClose, merchState)
+	assert.Nil(t, err)
-	assert.Equal(t, "merchant_close - Could not find entry for wpk & revoke token pair. Valid close!", err)
+	_, _, Err, err := BidirectionalMerchantClose(channelState, channelToken, "onChainAddress", custClose, merchState)
+	assert.Nil(t, err)
+	assert.Equal(t, "merchant_close - Could not find entry for wpk & revoke token pair. Valid close!", Err)
 }