Implement getting claim

Author: ben221199

rpc/claim.go

@@ -98,12 +98,98 @@ func convertProtobufToClaim(protobuf map[int]any, transactions map[string]any) m
 
 	claimValue := map[string]any{}
 
+	streamValue, streamOk := decodedProtobufClaimData[1]
+	if streamOk {
+		stream := streamValue.(map[int]any)
+
+		sourceValue, sourceOk := stream[1]
+		if sourceOk {
+			source := map[string]any{}
+
+			hashValue, hashOk := (sourceValue.(map[int]any))[1]
+			if hashOk {
+				hash := hex.EncodeToString(hashValue.([]uint8))
+				source["hash"] = hash
+			}
+
+			nameValue, nameOk := (sourceValue.(map[int]any))[2]
+			if nameOk {
+				name := string(nameValue.([]uint8))
+				source["name"] = name
+			}
+
+			mediaTypeValue, mediaTypeOk := (sourceValue.(map[int]any))[4]
+			if mediaTypeOk {
+				mediaType := string(mediaTypeValue.([]uint8))
+				source["media_type"] = mediaType
+			}
+
+			urlValue, urlOk := (sourceValue.(map[int]any))[5]
+			if urlOk {
+				url := string(urlValue.([]uint8))
+				source["url"] = url
+			}
+
+			sdHashValue, sdHashOk := (sourceValue.(map[int]any))[6]
+			if sdHashOk {
+				sdHash := hex.EncodeToString(sdHashValue.([]uint8))
+				source["sd_hash"] = sdHash
+			}
+
+			claimValue["source"] = source
+		}
+
+		authorValue, authorOk := stream[2]
+		if authorOk {
+			author := string(authorValue.([]uint8))
+			claimValue["author"] = author
+		}
+
+		licenseValue, licenseOk := stream[3]
+		if licenseOk {
+			license := string(licenseValue.([]uint8))
+			claimValue["license"] = license
+		}
+
+		licenseURLValue, licenseURLOk := stream[4]
+		if licenseURLOk {
+			licenseURL := string(licenseURLValue.([]uint8))
+			claimValue["license_url"] = licenseURL
+		}
+
+		// Temporary
+		claimValue["stream_type"] = "document"
+
+		_, hasStreamTypeImage := stream[10]
+		if hasStreamTypeImage {
+			claimValue["stream_type"] = "image"
+		}
+		_, hasStreamTypeVideo := stream[11]
+		if hasStreamTypeVideo {
+			claimValue["stream_type"] = "video"
+		}
+		_, hasStreamTypeAudio := stream[11]
+		if hasStreamTypeAudio {
+			claimValue["stream_type"] = "audio"
+		}
+		_, hasStreamTypeSoftware := stream[13]
+		if hasStreamTypeSoftware {
+			claimValue["stream_type"] = "software"
+		}
+	}
+
 	titleValue, titleOk := decodedProtobufClaimData[8]
 	if titleOk {
 		title := string(titleValue.([]uint8))
 		claimValue["title"] = title
 	}
 
+	descriptionValue, descriptionOk := decodedProtobufClaimData[9]
+	if descriptionOk {
+		description := string(descriptionValue.([]uint8))
+		claimValue["description"] = description
+	}
+
 	thumbnailValue, thumbnailOk := decodedProtobufClaimData[10]
 	if thumbnailOk {
 		thumbnail := map[string]any{}
@@ -128,5 +214,25 @@ func convertProtobufToClaim(protobuf map[int]any, transactions map[string]any) m
 
 	claim["value"] = claimValue
 
+	_, hasClaimTypeStream := decodedProtobufClaimData[1]
+	if hasClaimTypeStream {
+		claim["value_type"] = "stream"
+	}
+	_, hasClaimTypeChannel := decodedProtobufClaimData[2]
+	if hasClaimTypeChannel {
+		claim["value_type"] = "channel"
+	}
+	_, hasClaimTypeCollection := decodedProtobufClaimData[3]
+	if hasClaimTypeCollection {
+		claim["value_type"] = "collection"
+	}
+	_, hasClaimTypeRepost := decodedProtobufClaimData[4]
+	if hasClaimTypeRepost {
+		claim["value_type"] = "repost"
+	}
+
+	// 	claim["_1"] = protobuf
+	// 	claim["_2"] = decodedProtobufClaimData
+
 	return claim
 }

rpc/server.go

@@ -513,7 +513,75 @@ func handleJSONRPCMessageFileSetStatus(w http.ResponseWriter, params any) {
 
 func handleJSONRPCMessageGet(w http.ResponseWriter, params any) {
 	// Relaxed
-	sendErrorResponse(w, 501, "NOT IMPLEMENTED")
+	var paramsMap map[string]any = params.(map[string]any)
+
+	uri, _ := paramsMap["uri"].(string)
+
+	resolveResp, _ := SendJSON("s1.lbry.network", 50001, map[string]any{
+		"jsonrpc": "2.0",
+		"id":      rand.Int() + 1,
+		"method":  "blockchain.claimtrie.resolve",
+		"params":  []string{uri},
+	})
+
+	var resolutions map[string]any = map[string]any{}
+
+	_, resultIsString := resolveResp["result"].(string)
+	if resultIsString {
+		decodedBase64, _ := base64.StdEncoding.DecodeString(resolveResp["result"].(string))
+
+		decodedProtobuf, _ := DecodeRawProto(decodedBase64)
+
+		var resolutionData []any
+
+		_, okResolution := decodedProtobuf[1].([]any)
+		if okResolution {
+			resolutionData = decodedProtobuf[1].([]any)
+		} else {
+			resolutionData = []any{decodedProtobuf[1]}
+		}
+
+		txIDs := []string{}
+
+		for _, claim := range resolutionData {
+			claimMap := claim.(map[int]any)
+			txidValue, txidOk := claimMap[1]
+			if txidOk {
+				txidBytes := txidValue.([]byte)
+				slices.Reverse(txidBytes)
+				txID := hex.EncodeToString(txidBytes)
+				txIDs = append(txIDs, txID)
+			}
+		}
+
+		transactionResp, _ := SendJSON("s1.lbry.network", 50001, map[string]any{
+			"jsonrpc": "2.0",
+			"id":      rand.Int() + 1,
+			"method":  "blockchain.transaction.get_batch",
+			"params":  txIDs,
+		})
+
+		transactionData := transactionResp["result"].(map[string]any)
+
+		for _, claim := range resolutionData {
+			claimMap, ok := claim.(map[int]any)
+			if ok {
+				item := convertProtobufToClaim(claimMap, transactionData)
+
+				resolutionKey := uri
+				resolutions[resolutionKey] = item
+			}
+
+		}
+	}
+
+	sdHash := resolutions[uri].(map[string]any)["value"].(map[string]any)["source"].(map[string]any)["sd_hash"].(string)
+
+	streamingURL := "http://localhost:5280/stream/" + sdHash
+
+	sendResultResponse(w, map[string]any{
+		"streaming_url": streamingURL,
+	})
 }
 
 func handleJSONRPCMessagePeerList(w http.ResponseWriter, params any) {