Become a Model Provider

Search…
Setting up an MP service
Please refer to Go and Java code samples from respective links. 
Prerequisites
ONT ID
Each Model Provider must have a unique decentralized identifier (DID) to decrypt the data included in request messages. At present, it must be an ONT ID. You can get one by creating a wallet using ONTO app.
You can use one and the same DID to set up a DP and an MP.
Orange Provider SDK
An SDK in Go or Java is needed for signature and data encryption. Below instructions are illustrated in Go.
Wallet
You need to include a wallet file in the local directory of your project for decryption and signature. 
Design Models and Build Methods
Usually one model works with one dedicated dataset, so you need to design the model based on your dataset. Or, you can also choose to design and publish your model on the Orange platform and offer a bounty to attract a DP.
Models define the way data is used to determine the reputation for a user. You can create and customize models to define the operations that are performed on the data and the weightage that is assigned to data. 
One MP can provide multiple models to Orange users. Every model must have an associated method. A method is an abstract definition or reference to a model that is useful when querying and fetching data.
Each method needs to have a name and a parameter (dataset) associated with it.
The name is used to refer to a particular method
The parameter schema defines the useful data that needs to be passed as input to calculate reputation scores using the model pertaining to the particular method
Create Interfaces for Model Access
MPs need to set up an externally accessible interface with specific endpoints that can be used to fetch models. These endpoints will be called when model requests are made to the Orange system. The endpoint design depends on the design of the associated dataset, so only RESTful API is supported. 
Request
Requests should be made with parameters of the following in JSON:  
{
	"provider_did":"<dp did>",
	"data":<detail data>,
	"encrypted":"<encrypted hex string>"
}
Parameter
Description
provider_did
DID of DP
data
Data acquired from DP for calculation using the model. Usually it's empty in the production environment due to security concerns, only used in a debug environment.
encrypted
Hex string of data encrypted by DP using public key of MP's DID
Response
The response should be a score in JSON representing the user's reputation:
{
	"score":number
}
Publish Interface
When your interface is ready to be accessed on the mainnet, you can publish it on the Orange platform for developers to discover and use it. You can do it in the Reputation Studio.
Step 1: Click on the "Connect Wallet" button on the top right to connect your wallet. You can find a detailed guide here.
Step 2: Click on the Menu button and select "Management". Choose "My Models".
Step 3: Click on the "Create Profile" button and fill out the form to create your profile as an MP.
Step 4: Click on the "Create Model" and fill out the information following the steps indicated on the page. Then you can either click "Save" to save the draft, or click "Publish" to submit your model for review and publication.
Handle API Requests
Decrypt Request Messages
Since the data in the request is encrypted, you need first to decrypt the data. You need the Orange Go SDK and a wallet to decrypt a request using your DID.
Import SDK
import(
	orangeSDK "github.com/orange-protocol/orange-provider-go-sdk"
	orangeOnt "github.com/orange-protocol/orange-provider-go-sdk/ont"
)
Initialize SDK
didsdk, err := orangeOnt.NewOrangeProviderOntSdk("./wallet.dat", "123456", "TESTNET")
if err != nil {
    panic(err)
}
Parameters for initialization:
path of the wallet file
wallet password
network info: TESTNET or MAINNET
Example
requestJson := &BalanceReq{}
if err := c.ShouldBindJSON(requestJson); err != nil {
	c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
	return
}
		
encryptMsg, err := hex.DecodeString(requestJson.Encrypted)
if err != nil {
	fmt.Printf("DecodeString encryptMsg failed:%s\n", err.Error())
	c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
	return
}
// Decrypt the message with SDK
decryptedbts, err := didsdk.DecryptData(encryptMsg)
if err != nil {
	fmt.Printf("DecryptMsg failed:%s\n", err.Error())
	c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
	return
}
Verify DP Signature
After decryption, you'll get the data and the DP's signature to the data. To verify the authenticity of data, you need to verify DP's signature:
//1. Convert json to bytes
msgbytes, err := json.Marshal(dataWithSig.Data)
if err != nil {
fmt.Printf("Marshal msgbytes failed:%s\n", err.Error())
​
	c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
	return
}
//2. Deseriliaze signature
sigbytes, err := hex.DecodeString(dataWithSig.Sig)
if err != nil {
	fmt.Printf("DecodeString sigbytes failed:%s\n", err.Error())
​
	c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
	return
}
//3. Verify signature with SDK
f, err := didsdk.VerifySig(requestJson.ProviderDID, msgbytes, sigbytes)
if err != nil || !f {
	fmt.Printf("VerifySig  failed:%s\n", err.Error())
	c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Errorf("invalid signature")})
	return
}
Generate Responses
Now you can use the data to calculate a reputation score and send it back to the Orange system.  