Trust

In the BSV application ecosystem, every user controls a unique identity key through their BRC-100-compliant wallet. These wallets do far more than just create transactions or encrypt data; they form the backbone of identity on the Metanet. Because user identities do not rely on a platform’s authority—no single site or service “owns” an individual’s account—users must have some way to verify information shared among themselves. Enter the Metanet Trust Network.

Why the Metanet Trust Network?

Traditional social login approaches centralize our personas in the hands of a large third party (for example, a social media provider). In the BSV application ecosystem, users are the ones who hold and present the pieces proving who they are—digital certificates that bind their identity key (public key) to attributes like name, social media handle, or email. Instead of trusting a single central authority, each user decides independently which certifiers they trust to validate certain attributes. This you–control–your–data approach confers tremendous freedom but requires a new approach to trust.

Trust Points

Within your wallet’s settings:

• You decide which identity certifiers you want to trust (and how much).
• Each certifier is assigned a “trust value” in points. The higher the value, the more your wallet prefers that certifier’s certificate over others.

In effect, you run your own trust score system. The Metanet Trust Network is simply the sum of these individualized trust settings across all participants.

Identity Certificates in Brief

An “identity certificate” is a signed statement from a certifier. For instance:

• SocialCert might confirm a user’s handle on a microblogging platform.
• IdentiCert could verify a user’s legal name with processes akin to a government ID check.

These certificates use BRC-100’s standardized functions for issuance, selective revelation, and verification. Users store them in their wallets. Over time, a user might gather many certificates across multiple attributes (phone number, email, business role, legal name, membership in an organization, etc.).

Identity Resolution: Finding the Right Certificates

In day-to-day usage, your wallet calls two crucial methods (available in BRC-100 wallets):

• discoverByIdentityKey: “Given the public key of another user, which certificates from certifiers I trust can attest to this key’s attributes?”
• discoverByAttributes: “Find me keys that match certain attributes—for instance, users with an email of ‘user@example.com’ or a verified handle ‘@someone.’”

Identity Resolution is the process of answering these questions in real time, using your custom Trust Network settings to do it.

Example: Alice Meets Bob

• Alice trusts “SocialCert” at 5 points and “IdentiCert” at 8 points in her wallet’s settings.
• On a marketplace app, Bob lists an item for sale. The app sees Bob’s public key, consults Alice’s wallet, and runs discoverByIdentityKey(BobKey).
  • The wallet sees BobKey has a SocialCert certificate verifying “@BobBigIdeas.” Because SocialCert is in Alice’s trusted list at 5 points, the wallet returns that certificate to the app.
  • The app can display “@BobBigIdeas (verified by SocialCert)” next to Bob’s listings.
• For Bob, that means an immediate jump in credibility from Alice’s point of view.

Example: Carol’s Dual Certs

• Carol also sells items in the same marketplace.
• The app uses discoverByIdentityKey(CarolKey). This time, Carol has a SocialCert handle and an IdentiCert name certificate.
• Because Alice’s wallet sees IdentiCert is more trusted (8 points vs. 5), it surfaces Carol’s IdentiCert–verified name first: “Carol Simons.”
• Alice is even more confident transacting with Carol, seeing a higher-trust identity doc from IdentiCert.

Example: David’s Blank Slate

• David shows up with no certificates from any certifier that Alice trusts.
• The call to discoverByIdentityKey(DavidKey) yields no relevant results. So from Alice’s perspective, David remains “untrusted” or “unverified.”
• Apps can display him with minimal context, e.g. “No verified attributes.”

Building Your Own Trust Network

1. Pick Certifiers
   In your wallet’s settings, you select certifiers you find reliable. Maybe you trust “SocialCert” for social media handles, “IdentiCert” for legal name, “XPhoneCert” for phone verification, etc.

2. Assign Trust Points
   Each certifier gets a numerical trust value. This is fully in your control. You might set:

   • SocialCert: 5 points
   • IdentiCert: 8 points
   • SomeLessKnownCert: 2 points
   • Anyone that you do not trust to 0 points (excluded).

3. Pool of Certs
   Whenever your wallet tries to resolve an identity, it only returns certificates from the certifiers you trust. If multiple certificates apply, the wallet picks the highest scoring solution.

4. Fine-Tune Over Time
   If you find a certifier less reliable than expected, you can lower or remove its trust. The synergy is that you only see identity data from sources you regard as credible.

How It All Comes Together

When you open a Metanet-powered application—anything from a major social platform to a simple marketplace—and view another user:

1. The app obtains that user’s identity key.
2. The app instructs your wallet to “discover” certificates for that key (using discoverByIdentityKey under the hood).
3. Your wallet uses your trust settings to select and return the appropriate certificate(s).
4. The app can show you something you personally trust: e.g., “@someone (verified by SocialCert, 5 points),” or “John Smith (verified by IdentiCert, 8 points).”

Where once a single website might forcibly unify everyone’s account under its own database, now your personal settings determine which attributes you see. It’s your own portable trust system.

Searching by Attributes

Some BSV apps do background checks via discoverByAttributes, such as:

• Searching for a user by email to see if it matches a public key, if the user has an email certificate from a trusted certifier.
• Checking that a user is truly part of a certain organization or location attribute.

This flips the usual identity approach: instead of a site verifying you, your wallet (on your machine) queries your existing identity data from the network of certifiers you trust. It’s a peer-to-peer approach built directly into BRC-100’s identity features.

Developer Resources

To incorporate these capabilities into your own applications or services:

1. IdentityClient from @bsv/sdk:

   • Provides straightforward methods (resolveByIdentityKey, resolveByAttributes) for identity resolution.
   • Handles selective revelation (like showing only name and avatar, not private details).
   • Integrates with the standard BRC-100 wallet interface to perform queries and validations.

2. React Components in @bsv/identity-react:

   • Quickly add identity-rich user interfaces to your Metanet-powered site.
   • Drop in an <IdentityCard /> or <IdentitySearchField /> to display user certificates or let users search for others by name/key.
   • Handling all logic behind the scenes, leaving you free to focus on the bigger app.

Both the SDK and React components tap into the same identity flows described here: trusting certain certifiers, discovering certificates for a given key, or searching by attributes. This is your gateway to building user experiences where trust is personal, data is user-owned, and identity is as flexible or rigorous as you—and your users—want it to be.

In short, the Metanet Trust Network and the BRC-100 identity model let each user run their own “trust mini–ecosystem.” Real-time Identity Resolution is as simple as your wallet calling the discovery functions on behalf of the apps you use. This fosters a more open, user-centric, and privacy-honoring experience—one certificate at a time.