// Query callback representing the query of a chaincode
func (t *systemChaincode) Query(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
if function != "query" {
return nil, errors.New("Invalid query function name. Expecting \"query\"")
}
if len(args) != 1 {
return nil, errors.New("Incorrect number of arguments. Expecting 1")
}
key := args[0]
if key != systemValidityPeriodKey {
return nil, errors.New("Incorrect key. Expecting " + systemValidityPeriodKey)
}
// Get the state from the ledger
vp, err := stub.GetState(key)
if err != nil {
jsonResp := "{\"Error\":\"Failed to get state for " + key + "\"}"
return nil, errors.New(jsonResp)
}
if vp == nil {
jsonResp := "{\"Error\":\"Nil value for " + key + "\"}"
return nil, errors.New(jsonResp)
}
jsonResp := "{\"Name\":\"" + key + "\",\"Value\":\"" + string(vp) + "\"}"
fmt.Printf("Query Response:%s\n", jsonResp)
return []byte(jsonResp), nil
}
// Query callback representing the query of a chaincode
func (t *SimpleChaincode) Query(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
if function != "query" {
return nil, errors.New("Invalid query function name. Expecting \"query\"")
}
var A string // Entity
var Aval int // Asset holding
var err error
if len(args) != 2 {
return nil, errors.New("Incorrect number of arguments. Expecting 2")
}
A = args[0]
Aval, err = strconv.Atoi(args[1])
if err != nil {
return nil, errors.New("Expecting integer value for asset holding")
}
fmt.Printf("Aval = %d\n", Aval)
// Write the state to the ledger - this put is illegal within Run
err = stub.PutState(A, []byte(strconv.Itoa(Aval)))
if err != nil {
jsonResp := "{\"Error\":\"Cannot put state within chaincode query\"}"
return nil, errors.New(jsonResp)
}
fmt.Printf("Something is wrong. This query should not have succeeded")
return nil, nil
}
// Query callback representing the query of a chaincode
func (t *SampleSysCC) Query(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
if function != "getval" {
return nil, errors.New("Invalid query function name. Expecting \"getval\"")
}
var key string // Entities
var err error
if len(args) != 1 {
return nil, errors.New("Incorrect number of arguments. Expecting key to query")
}
key = args[0]
// Get the state from the ledger
valbytes, err := stub.GetState(key)
if err != nil {
jsonResp := "{\"Error\":\"Failed to get state for " + key + "\"}"
return nil, errors.New(jsonResp)
}
if valbytes == nil {
jsonResp := "{\"Error\":\"Nil val for " + key + "\"}"
return nil, errors.New(jsonResp)
}
return valbytes, nil
}
//==============================================================================================================================
// General Functions
//==============================================================================================================================
// get_ecert - Takes the name passed and calls out to the REST API for HyperLedger to retrieve the ecert
// for that user. Returns the ecert as retrived including html encoding.
//==============================================================================================================================
func (t *SimpleChaincode) get_ecert(stub *shim.ChaincodeStub, name string) ([]byte, error) {
var cert ECertResponse
peer_address, err := stub.GetState("Peer_Address")
if err != nil {
return nil, errors.New("Error retrieving peer address")
}
response, err := http.Get("http://" + string(peer_address) + "/registrar/" + name + "/ecert") // Calls out to the HyperLedger REST API to get the ecert of the user with that name
if err != nil {
return nil, errors.New("Error calling ecert API")
}
defer response.Body.Close()
contents, err := ioutil.ReadAll(response.Body) // Read the response from the http callout into the variable contents
if err != nil {
return nil, errors.New("Could not read body")
}
err = json.Unmarshal(contents, &cert)
if err != nil {
return nil, errors.New("Could not retrieve ecert for user: " + name)
}
return []byte(string(cert.OK)), nil
}
func createTableThree(stub *shim.ChaincodeStub) error {
var columnDefsTableThree []*shim.ColumnDefinition
columnOneTableThreeDef := shim.ColumnDefinition{Name: "colOneTableThree",
Type: shim.ColumnDefinition_STRING, Key: true}
columnTwoTableThreeDef := shim.ColumnDefinition{Name: "colTwoTableThree",
Type: shim.ColumnDefinition_INT32, Key: false}
columnThreeTableThreeDef := shim.ColumnDefinition{Name: "colThreeTableThree",
Type: shim.ColumnDefinition_INT64, Key: false}
columnFourTableThreeDef := shim.ColumnDefinition{Name: "colFourTableFour",
Type: shim.ColumnDefinition_UINT32, Key: false}
columnFiveTableThreeDef := shim.ColumnDefinition{Name: "colFourTableFive",
Type: shim.ColumnDefinition_UINT64, Key: false}
columnSixTableThreeDef := shim.ColumnDefinition{Name: "colFourTableSix",
Type: shim.ColumnDefinition_BYTES, Key: false}
columnSevenTableThreeDef := shim.ColumnDefinition{Name: "colFourTableSeven",
Type: shim.ColumnDefinition_BOOL, Key: false}
columnDefsTableThree = append(columnDefsTableThree, &columnOneTableThreeDef)
columnDefsTableThree = append(columnDefsTableThree, &columnTwoTableThreeDef)
columnDefsTableThree = append(columnDefsTableThree, &columnThreeTableThreeDef)
columnDefsTableThree = append(columnDefsTableThree, &columnFourTableThreeDef)
columnDefsTableThree = append(columnDefsTableThree, &columnFiveTableThreeDef)
columnDefsTableThree = append(columnDefsTableThree, &columnSixTableThreeDef)
columnDefsTableThree = append(columnDefsTableThree, &columnSevenTableThreeDef)
return stub.CreateTable("tableThree", columnDefsTableThree)
}
func createTableFour(stub *shim.ChaincodeStub) error {
var columnDefsTableFour []*shim.ColumnDefinition
columnOneTableFourDef := shim.ColumnDefinition{Name: "colOneTableFour",
Type: shim.ColumnDefinition_STRING, Key: true}
columnDefsTableFour = append(columnDefsTableFour, &columnOneTableFourDef)
return stub.CreateTable("tableFour", columnDefsTableFour)
}
// Invoke has two functions
// put - takes two arguements, a key and value, and stores them in the state
// remove - takes one argument, a key, and removes if from the state
func (t *SimpleChaincode) Invoke(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
switch function {
case "put":
if len(args) < 2 {
return nil, errors.New("put operation must include two arguments, a key and value")
}
key := args[0]
value := args[1]
err := stub.PutState(key, []byte(value))
if err != nil {
fmt.Printf("Error putting state %s", err)
return nil, fmt.Errorf("put operation failed. Error updating state: %s", err)
}
return nil, nil
case "remove":
if len(args) < 1 {
return nil, errors.New("remove operation must include one argument, a key")
}
key := args[0]
err := stub.DelState(key)
if err != nil {
return nil, fmt.Errorf("remove operation failed. Error updating state: %s", err)
}
return nil, nil
default:
return nil, errors.New("Unsupported operation")
}
}
// Query callback representing the query of a chaincode
// Supported functions are the following:
// "query(asset)": returns the owner of the asset.
// Anyone can invoke this function.
func (t *AssetManagementChaincode) Query(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
myLogger.Debugf("Query [%s]", function)
if function != "query" {
return nil, errors.New("Invalid query function name. Expecting \"query\"")
}
var err error
if len(args) != 1 {
myLogger.Debug("Incorrect number of arguments. Expecting name of an asset to query")
return nil, errors.New("Incorrect number of arguments. Expecting name of an asset to query")
}
// Who is the owner of the asset?
asset := args[0]
myLogger.Debugf("Arg [%s]", string(asset))
var columns []shim.Column
col1 := shim.Column{Value: &shim.Column_String_{String_: asset}}
columns = append(columns, col1)
row, err := stub.GetRow("AssetsOwnership", columns)
if err != nil {
myLogger.Debugf("Failed retriving asset [%s]: [%s]", string(asset), err)
return nil, fmt.Errorf("Failed retriving asset [%s]: [%s]", string(asset), err)
}
myLogger.Debugf("Query done [% x]", row.Columns[1].GetBytes())
return row.Columns[1].GetBytes(), nil
}
// "create": true -> create new ID, false -> append the id
func append_id(stub *shim.ChaincodeStub, indexStr string, id string, create bool) ([]byte, error) {
indexAsBytes, err := stub.GetState(indexStr)
if err != nil {
return nil, errors.New("Failed to get " + indexStr)
}
fmt.Println(indexStr + " retrieved")
// Unmarshal the index
var tmpIndex []string
json.Unmarshal(indexAsBytes, &tmpIndex)
fmt.Println(indexStr + " unmarshalled")
// Create new id
var newId = id
if create {
newId += strconv.Itoa(len(tmpIndex) + 1)
}
// append the new id to the index
tmpIndex = append(tmpIndex, newId)
jsonAsBytes, _ := json.Marshal(tmpIndex)
err = stub.PutState(indexStr, jsonAsBytes)
if err != nil {
return nil, errors.New("Error storing new " + indexStr + " into ledger")
}
return []byte(newId), nil
}
func (t *SimpleChaincode) get_all_devices(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
devicesIndexBytes, err := stub.GetState(deviceIndexStr)
if err != nil {
return nil, errors.New("Failed to get devices index")
}
var deviceIndex []string
err = json.Unmarshal(devicesIndexBytes, &deviceIndex)
if err != nil {
return nil, errors.New("Could not marshal device indexes")
}
var devices []Device
for _, deviceId := range deviceIndex {
bytes, err := stub.GetState(deviceId)
if err != nil {
return nil, errors.New("Not able to get device")
}
var d Device
err = json.Unmarshal(bytes, &d)
devices = append(devices, d)
}
devicesJson, err := json.Marshal(devices)
if err != nil {
return nil, errors.New("Failed to marshal devices to JSON")
}
return devicesJson, nil
}
func (t *SimpleChaincode) get_all_bids(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
bidIndexBytes, err := stub.GetState(bidIndexStr)
if err != nil {
return nil, errors.New("Failed to get bids index")
}
var bidIndex []string
err = json.Unmarshal(bidIndexBytes, &bidIndex)
if err != nil {
return nil, errors.New("Could not marshal bid indexes")
}
var bids []Bid
for _, bidId := range bidIndex {
bytes, err := stub.GetState(bidId)
if err != nil {
return nil, errors.New("Not able to get bid")
}
var b Bid
err = json.Unmarshal(bytes, &b)
bids = append(bids, b)
}
bidsJson, err := json.Marshal(bids)
if err != nil {
return nil, errors.New("Failed to marshal bids to JSON")
}
return bidsJson, nil
}
// Query callback representing the query of a chaincode
func (t *SimpleChaincode) Query(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
if function != "query" {
return nil, errors.New("Invalid query function name. Expecting \"query\"")
}
var A string // Entities
var err error
if len(args) != 1 {
return nil, errors.New("Incorrect number of arguments. Expecting name of the person to query")
}
A = args[0]
// Get the state from the ledger
Avalbytes, err := stub.GetState(A)
if err != nil {
jsonResp := "{\"Error\":\"Failed to get state for " + A + "\"}"
return nil, errors.New(jsonResp)
}
if Avalbytes == nil {
jsonResp := "{\"Error\":\"Nil amount for " + A + "\"}"
return nil, errors.New(jsonResp)
}
jsonResp := "{\"Name\":\"" + A + "\",\"Amount\":\"" + string(Avalbytes) + "\"}"
fmt.Printf("Query Response:%s\n", jsonResp)
return Avalbytes, nil
}
func (t *SimpleChaincode) Init(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
var A, B string // Entities
var Aval, Bval int // Asset holdings
var err error
if len(args) != 4 {
return nil, errors.New("Incorrect number of arguments. Expecting 4")
}
// Initialize the chaincode
A = args[0]
Aval, err = strconv.Atoi(args[1])
if err != nil {
return nil, errors.New("Expecting integer value for asset holding")
}
B = args[2]
Bval, err = strconv.Atoi(args[3])
if err != nil {
return nil, errors.New("Expecting integer value for asset holding")
}
fmt.Printf("Aval = %d, Bval = %d\n", Aval, Bval)
// Write the state to the ledger
err = stub.PutState(A, []byte(strconv.Itoa(Aval)))
if err != nil {
return nil, err
}
err = stub.PutState(B, []byte(strconv.Itoa(Bval)))
if err != nil {
return nil, err
}
return nil, nil
}
// Init takes two arguments, a string and int. The string will be a key with
// the int as a value.
func (t *SimpleChaincode) Init(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
var sum string // Sum of asset holdings across accounts. Initially 0
var sumVal int // Sum of holdings
var err error
if len(args) != 2 {
return nil, errors.New("Incorrect number of arguments. Expecting 2")
}
// Initialize the chaincode
sum = args[0]
sumVal, err = strconv.Atoi(args[1])
if err != nil {
return nil, errors.New("Expecting integer value for sum")
}
fmt.Printf("sumVal = %d\n", sumVal)
// Write the state to the ledger
err = stub.PutState(sum, []byte(strconv.Itoa(sumVal)))
if err != nil {
return nil, err
}
return nil, nil
}
// Invoke gets the supplied key and if it exists, updates the key with the newly
// supplied value.
func (t *SampleSysCC) Invoke(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
var key, val string // Entities
if len(args) != 2 {
return nil, errors.New("need 2 args (key and a value)")
}
// Initialize the chaincode
key = args[0]
val = args[1]
_, err := stub.GetState(key)
if err != nil {
jsonResp := "{\"Error\":\"Failed to get val for " + key + "\"}"
return nil, errors.New(jsonResp)
}
// Write the state to the ledger
err = stub.PutState(key, []byte(val))
if err != nil {
return nil, err
}
return nil, nil
}
// Query callback representing the query of a chaincode
func (t *AssetManagementChaincode) Query(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
if function != "query" {
return nil, errors.New("Invalid query function name. Expecting \"query\"")
}
var err error
if len(args) != 1 {
return nil, errors.New("Incorrect number of arguments. Expecting name of an asset to query")
}
// Who is the owner of the asset?
asset := args[0]
var columns []shim.Column
col1 := shim.Column{Value: &shim.Column_String_{String_: asset}}
columns = append(columns, col1)
row, err := stub.GetRow("AssetsOwnership", columns)
if err != nil {
jsonResp := "{\"Error\":\"Failed retrieving asset " + asset + ". Error " + err.Error() + ". \"}"
return nil, errors.New(jsonResp)
}
jsonResp := "{\"Owner\":\"" + string(row.Columns[1].GetBytes()) + "\"}"
fmt.Printf("Query Response:%s\n", jsonResp)
return row.Columns[1].GetBytes(), nil
}
// ============================================================================================================================
// Set User Permission on Marble
// ============================================================================================================================
func (t *SimpleChaincode) set_user(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
var err error
// 0 1
// "name", "bob"
if len(args) < 2 {
return nil, errors.New("Incorrect number of arguments. Expecting 2")
}
fmt.Println("- start set user")
fmt.Println(args[0] + " - " + args[1])
marbleAsBytes, err := stub.GetState(args[0])
if err != nil {
return nil, errors.New("Failed to get thing")
}
res := Marble{}
json.Unmarshal(marbleAsBytes, &res) //un stringify it aka JSON.parse()
res.User = args[1] //change the user
jsonAsBytes, _ := json.Marshal(res)
err = stub.PutState(args[0], jsonAsBytes) //rewrite the marble with id as key
if err != nil {
return nil, err
}
fmt.Println("- end set user")
return nil, nil
}
// ============================================================================================================================
// findMarble4Trade - look for a matching marble that this user owns and return it
// ============================================================================================================================
func findMarble4Trade(stub *shim.ChaincodeStub, user string, color string, size int) (m Marble, err error) {
var fail Marble
fmt.Println("- start find marble 4 trade")
fmt.Println("looking for " + user + ", " + color + ", " + strconv.Itoa(size))
//get the marble index
marblesAsBytes, err := stub.GetState(marbleIndexStr)
if err != nil {
return fail, errors.New("Failed to get marble index")
}
var marbleIndex []string
json.Unmarshal(marblesAsBytes, &marbleIndex) //un stringify it aka JSON.parse()
for i := range marbleIndex { //iter through all the marbles
//fmt.Println("looking @ marble name: " + marbleIndex[i]);
marbleAsBytes, err := stub.GetState(marbleIndex[i]) //grab this marble
if err != nil {
return fail, errors.New("Failed to get marble")
}
res := Marble{}
json.Unmarshal(marbleAsBytes, &res) //un stringify it aka JSON.parse()
//fmt.Println("looking @ " + res.User + ", " + res.Color + ", " + strconv.Itoa(res.Size));
//check for user && color && size
if strings.ToLower(res.User) == strings.ToLower(user) && strings.ToLower(res.Color) == strings.ToLower(color) && res.Size == size {
fmt.Println("found a marble: " + res.Name)
fmt.Println("! end find marble 4 trade")
return res, nil
}
}
fmt.Println("- end find marble 4 trade - error")
return fail, errors.New("Did not find marble to use in this trade")
}
// ============================================================================================================================
// Init - reset all the things
// ============================================================================================================================
func (t *SimpleChaincode) Init(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
var Aval int
var err error
if len(args) != 1 {
return nil, errors.New("Incorrect number of arguments. Expecting 1")
}
// Initialize the chaincode
Aval, err = strconv.Atoi(args[0])
if err != nil {
return nil, errors.New("Expecting integer value for asset holding")
}
// Write the state to the ledger
err = stub.PutState("abc", []byte(strconv.Itoa(Aval))) //making a test var "abc", I find it handy to read/write to it right away to test the network
if err != nil {
return nil, err
}
var empty []string
jsonAsBytes, _ := json.Marshal(empty) //marshal an emtpy array of strings to clear the index
err = stub.PutState(marbleIndexStr, jsonAsBytes)
if err != nil {
return nil, err
}
return nil, nil
}
//==============================================================================================================================
// Invoke Functions
//==============================================================================================================================
// add_number - Retrieves the current number value stored in the world state and adds a number passed by the invoker to it
// and updates Number to the new value in the world state
//==============================================================================================================================
func (t *SimpleChaincode) add_number(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
//Args
// 0
// Value to add
adder, _ := strconv.Atoi(args[0])
bytes, err := stub.GetState("Number")
if err != nil {
return nil, errors.New("Unable to get number")
}
number, _ := strconv.Atoi(string(bytes))
newNumber := number + adder
toPut := strconv.Itoa(newNumber)
err = stub.PutState("Number", []byte(toPut))
if err != nil {
return nil, errors.New("Unable to put the state")
}
return nil, nil
}
func (t *SimpleChaincode) get_all_slots(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
slotsIndexBytes, err := stub.GetState(slotIndexStr)
if err != nil {
return nil, errors.New("Failed to get slots index")
}
var slotIndex []string
err = json.Unmarshal(slotsIndexBytes, &slotIndex)
if err != nil {
return nil, errors.New("Could not marshal slot indexes")
}
var slots []Slot
for _, slotId := range slotIndex {
bytes, err := stub.GetState(slotId)
if err != nil {
return nil, errors.New("Not able to get slot")
}
var s Slot
err = json.Unmarshal(bytes, &s)
slots = append(slots, s)
}
slotsJson, err := json.Marshal(slots)
if err != nil {
return nil, errors.New("Failed to marshal slots to JSON")
}
return slotsJson, nil
}
//==============================================================================================================================
// Init Function - Called when the user deploys the chaincode sets up base vehicle_logs (blank array)
//==============================================================================================================================
func (t *SimpleChaincode) Init(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
//Args
// 0
// peer_address
var eh Vehicle_Log_Holder
bytes, err := json.Marshal(eh)
if err != nil {
return nil, errors.New("Error creating vehicle_log record")
}
err = stub.PutState("Vehicle_Logs", bytes)
if err != nil {
return nil, errors.New("Error creating blank vehicle_log array")
}
err = stub.PutState("Peer_Address", []byte(args[0]))
if err != nil {
return nil, errors.New("Error storing peer address")
}
return nil, nil
}
// Init function
func (t *EventSender) Init(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
err := stub.PutState("noevents", []byte("0"))
if err != nil {
return nil, err
}
return nil, nil
}
// Query function
func (t *EventSender) Query(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
b, err := stub.GetState("noevents")
if err != nil {
return nil, errors.New("Failed to get state")
}
jsonResp := "{\"NoEvents\":\"" + string(b) + "\"}"
return []byte(jsonResp), nil
}
func (t *SampleChaincode) Query(stub *shim.ChaincodeStub, function string, args []string) ([]byte, error) {
if len(args) != 1 {
return nil, errors.New("<name>")
}
return stub.GetState(args[0])
}
// queryTable returns the record row matching a correponding account ID on the chaincode state table
// stub: chaincodestub
// accountID: account ID
func (t *depositoryHandler) queryTable(stub *shim.ChaincodeStub, accountID string) (shim.Row, error) {
var columns []shim.Column
col1 := shim.Column{Value: &shim.Column_String_{String_: accountID}}
columns = append(columns, col1)
return stub.GetRow(tableColumn, columns)
}
// createTable initiates a new asset depository table in the chaincode state
// stub: chaincodestub
func (t *depositoryHandler) createTable(stub *shim.ChaincodeStub) error {
// Create asset depository table
return stub.CreateTable(tableColumn, []*shim.ColumnDefinition{
&shim.ColumnDefinition{Name: columnAccountID, Type: shim.ColumnDefinition_STRING, Key: true},
&shim.ColumnDefinition{Name: columnContactInfo, Type: shim.ColumnDefinition_STRING, Key: false},
&shim.ColumnDefinition{Name: columnAmount, Type: shim.ColumnDefinition_UINT64, Key: false},
})
}
func writeHome(stub *shim.ChaincodeStub,home Home) (error) {
homeBytes, err := json.Marshal(&home)
if err != nil {
return err
}
err = stub.PutState(home.Address, homeBytes)
if err != nil {
return errors.New("PutState Error" + err.Error())
}
return nil
}
func writeCenterBank(stub *shim.ChaincodeStub, centerBank CenterBank) error {
cbBytes, err := json.Marshal(¢erBank)
if err != nil {
return err
}
err = stub.PutState("centerBank", cbBytes)
if err != nil {
return errors.New("PutState Error" + err.Error())
}
return nil
}
//==============================================================================================================================
// Invoke Functions
//==============================================================================================================================
// add_number - Invokes the numbers chaincode and calls the function add_number, chaincode name currently hardcoded
//
//==============================================================================================================================
func (t *SimpleChaincode) add_number(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
_, err := stub.InvokeChaincode("970000a712cf185274f39566276b18591c125ab41ee2674b3ccfeeed3e95a21b7129a4b97598e7807a362b345609caa8985f28f68e3a1614e0f12dcd99d3a589", "add_number", args)
if err != nil {
return nil, errors.New("Unable to invoke chaincode")
}
return nil, nil
}