[4] Proof of Contribution: Attribution (Request for Cores, RfCs)

Overview

A key principle in achieving a more perfect meritocracy is the measurability of the economy.

To achieve this, x/brahma maintains a global view of each actor's relevant contributions to each AI.

This view is periodically updated via Requests for Core, submitted by Bitplanet applications who wish to reward actors for their economically productive behavior.

Note: tensor state and computed-tensor state may be move off chain or on a modular DA layer in the future to manage potential accelerating state bloat.

Implementation

Data Structures

We define the following data-structures for x/brahma:

message ContributionType {
  string name = 1;
  string description = 2;
  bool active = 3;
}

message ContributionTypes {
  repeated ContributionType types = 1;
}

message AITensorRow {
  string address = 1;
  repeated uint64 contributions = 2;
}

message AITensor {
  repeated AITensorRow tensor = 1;
  bytes AI = 2;
}


message MsgCoreGrantApplication {
  option (cosmos.msg.v1.signer) = "authority";
  option (amino.name) = "spawn/x/brahma/MsgCoreGrantApplication";

  string authority = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"];
  string requester = 2 [(cosmos_proto.scalar) = "cosmos.AddressString"];
  uint64 core_allocation = 3;
  string title = 4;
  string description = 5;
  int64 created_at_height = 6;
}


// MsgRequestForCore represents the actual request to issue new Core. Requester is expected to have been a Grantee on a previously approved CoreGrant.
// On execution, this message will trigger the issuance of new Cores in accordance with each ore listed in the AITensors provided. This will also
// update the referenced AI's state-tensors.
message MsgRequestForCore {
  option (cosmos.msg.v1.signer) = "requester";
  option (amino.name) = "spawn/x/brahma/MsgRequestForCore";

  // Requester is the requester of this RequestForCore
  string requester = 1 [(cosmos_proto.scalar) = "cosmos.AddressString"];

  // AITensors determine the set of cores to be issued from this MsgRequestCore
  repeated AITensor AITensors = 2;
}

ContributionType

ContributionType defines the types of economically productive activities that can be rewarded with Cores. The system maintains a governance-managed list of contribution types via the ContributionTypes parameter.

Each contribution type has:

• name: The identifier for the contribution type (e.g., "CREATE", "TRAIN", "REFER")

• description: Human-readable explanation of the contribution type

• active: Boolean flag allowing governance to deactivate types without removing them

Default Contribution Types:

1. TRAIN - Contributions towards training the AI

2. REFER - Referring new participants or resources to the AI

3. CREATE - Creating new AI or significant improvements (required)

4. PROMPT - Formulating prompts that enhance AI interactions

5. REVENUE - Generating revenue for the AI

6. MARKET_CAP - Increasing the market capitalization of the AI

The contributions array in AITensorRow is indexed by position in the ContributionTypes list. For example, if ContributionTypes = ["CREATE", "TRAIN", "REFER"], then contributions[0] represents CREATE contributions, contributions[1] represents TRAIN contributions, etc.

AITensor

Each AITensor represents the aggregate contributions per actor for a specific AI.

We may treat this object like a 2d-matrix, in which we can define the following operations:

1. Add: standard element-wise addition

2. Product: standard matrix multiplication operation.

MsgCoreGrantApplication

A CoreGrantApplication is a proposal, through which, applications that wish to issue Cores to reward their users, will be granted a fixed allowance of core_allocation.

Each CoreGrantApplication will have an associated requester that will be permitted to submit RequestForCores until their allowance is spent. At which point, the application will have to submit another CoreGrantApplication.

MsgCoreGrantApplications will be executed by the cosmos-sdk x/gov module after a succesful proposal submission. The process of submitting a MsgCoreGrantApplication proposal is the same as for any x/gov proposal.

MsgRequestForCore

A MsgRequestForCore is to be submitted by the requester of a previous CoreGrantApplication proposal.

This message is to be signed + submitted only by the requester, and will deduct from their spendable allowance of Cores.

On execution, this message will create new Cores in the EVM, and will update the x/brahma's internal AITensors for each AI referenced in the message.

State

The relevant parts of the x/brahma state will look like this

// AIID is a unique identifier for an AI
type AIID [32]byte

type BrahmaState struct {
  // AITensors is the aggregate set of contributions to all AI at any height
  AITensors map[AIID]map[uint64]AITensor // AI -> height -> AITensor

  // CoreGrantApplications are the set of active CoreGrantApplications, these will be spent by each RequestForCore
  CoreGrantApplications map[sdk.AccAddress]MsgCoreGrantApplication // address -> CoreGrantApplication

  // additional fields...
}

AITensors

All contributions for each AI are measured via the AITensors object.

For each height all AI mentioned in RequestsForcores submitted at that height will update the AITensors[AIID][height] tensor object.

Notice, the AITensors state is derived from the issued Cores. This means that the total supply of Cores + inscripted contributions on each Core, is the canonical contribution state.

This object will be exposed to the EVM via precompiles, thus enabling non-linearities for contract developers who'd like to introspect the global attribution state.

CoreGrantApplications

CoreGrantApplications are the set of allowances per requesters for all open grants.

Each MsgRequestForCore will spend from this allowance.

State Transitions

MsgRequestForCore

The following pseudo code defines the behavior of the MsgRequestForCore logic:

func (k BrahmaState) RequestForCore(ctx sdk.Context, msg MsgRequestForCore) error {
  // get the CoreGrantApplication for the requester
  cga, found := k.GetCoreGrantApplication(ctx, msg.requester)
  if !found {
    return fmt.Errorf("requester: %s does not have a CoreGrantApplication", msg.requester)
  }

  // check to see if the total Core issued is available in the spendable balance
  totalCoresToIssue := tallyCores(msg.AITensors)
  if cga.CoreAllocation < totalCoresToIssue {
    return fmt.Errorf("Cores to issue: %d is greater than spendable allowance: %d", totalCoresToIssue, cga.CoreAllocation)
  }

  // update each AI's state for the current-height + issue Cores
  for _, AI := range msg.AITensors {
    // issue Cores + return for use in AI tensor creation
    cores, err := k.IssueCores(ctx, AI)
    if err != nil {
      return fmt.Errorf("error issuing cores for AI %v: %v", AI, err)
    }

    // update the AITensor state for the AI
    if err := k.UpdateOrCreateAITensorState(ctx, AI, cores); err != nil {
      return err
    }
  }

  // deduct from the CoreGrantApplication allowance
  cga.CoreAllocation -= totalCoresToIssue
  k.SetCoreGrantApplication(ctx, msg.requester, cga)

  return nil
}

// tallyCores will iterate through all entries in each AITensor and sum them to determine to total # of Cores to issue.
func tallyCores(AI []AITensor) uint64

// IssueCores will issue the necessary Cores for each entry in the AITensor provided
func (k BrahmaState) IssueCores(ctx sdk.Context, AI AITensor) ([]Core, error)

// UpdateOrCreateAITensorState will update (or create) the AI tensor state at the given height for the AI
func (k BrahmaState) UpdateOrCreateAITensorState(ctx sdk.Context, AI AITensor, cores []Core) error

MsgCoreGrantApplication

func (k BrahmaState) CoreGrantApplication(ctx sdk.Context, msg MsgCoreGrantApplication) error {
  // check if the authority is the x/gov module address
  if !msg.Authority.Equals(gov.ModuleAddress()) {
    return fmt.Errorf("signer %s is not the governance module address: %s", msg.Authority, gov.ModuleAddress())
  }

  // get current grant if it exists, otherwise create new one
  currentCGA, found := k.GetCoreGrantApplication(ctx, msg.Requester)
  currentAllocation := uint64(0)
  if found {
    currentAllocation = currentCGA.CoreAllocation
  } else {
    currentCGA = MsgCoreGrantApplication{
      Requester:       msg.Requester,
      CoreAllocation:  0,
      CreatedAtHeight: ctx.BlockHeight(),
    }
  }

  // update the allocation (can be incremented multiple times)
  currentCGA.CoreAllocation = currentAllocation + msg.CoreAllocation

  // set the updated grant in state
  k.SetCoreGrantApplication(ctx, msg.Requester, currentCGA)
}