Skip to main content

Create Triple

Triples are higher-order structures in the Intuition system, used to define relationships between Atoms. Each Triple consists of three components - Subject, Predicate, and Object - all represented as Atoms, enabling precise, machine-readable representations of data relationships.

Context​

The createTriple and batchCreateTriple functions are part of the EthMultiVault contract, which manages the creation and relationships between Atoms through Semantic Triples. When creating Triples, each component must reference existing Atom vault IDs. The Triple structure enables:

  • Many-to-one attestations
  • Positive and negative signaling through triple vaults
  • Flat data structures for optimal scalability

For example, a Triple might represent:

  • Subject: "Bob" (Atom ID: "1")
  • Predicate: "is" (Atom ID: "2")
  • Object: "Trustworthy" (Atom ID: "3")

createTriple​

function createTriple(
    uint256 subjectId,
    uint256 predicateId,
    uint256 objectId
) external payable nonReentrant whenNotPaused returns (uint256)

Parameters​

  • subjectId: vault ID of the Atom representing the subject
  • predicateId: vault ID of the Atom representing the predicate/relationship
  • objectId: vault ID of the Atom representing the object
  • value : Initial deposit into the Triple’s positive multivault. Must be ≥ to the triple creation cost.
  • Returns: uint256 - Created triple vault ID

Implementation​

// useCreateTriple Hook
import { type GetContractReturnType } from 'viem'
import { base } from 'viem/chains'
import { useContractWriteAndWait } from './useContractWriteAndWait'
import { useMultivaultContract } from './useMultivaultContract'

export const useCreateTriple = () => {
  const multivault = useMultivaultContract(
    base.id
  ) as GetContractReturnType

  return useContractWriteAndWait({
    ...multivault,
    functionName: 'createTriple',
  })
}
// Usage Example
const {
  writeAsync: writeCreateTriple,
  awaitingWalletConfirmation,
  awaitingOnChainConfirmation,
} = useCreateTriple()

async function handleCreateTriple(subjectId: string, predicateId: string, objectId: string) {
  if (!awaitingOnChainConfirmation && !awaitingWalletConfirmation && writeCreateTriple) {
    try {
      const tx = await writeCreateTriple({
        address: MULTIVAULT_CONTRACT_ADDRESS,
        abi: multivaultAbi,
        functionName: 'createTriple',
        args: [BigInt(subjectId), BigInt(predicateId), BigInt(objectId)],
        value: tripleCost, // Must be >= minimum creation cost
      })
      
      if (tx?.hash) {
        const receipt = await publicClient.waitForTransactionReceipt({
          hash: tx.hash,
        })
        // Handle success
      }
    } catch (error) {
      // Handle error
    }
  }
}

createBatchTriple​

function createTripleBatch(
    uint256[] calldata subjectIds,
    uint256[] calldata predicateIds,
    uint256[] calldata objectIds
) external payable nonReentrant whenNotPaused returns (uint256[] memory)

Parameters​

  • subjectIds: vault ID(s) of the Atom representing the subjects
  • predicateIds: vault ID(s) of the Atom representing the predicate/relationships
  • objectIds: vault ID(s) of the Atom representing the objects
  • value : Initial deposit into the triples’ multivaults. Must be ≥ to the atom creation cost * length of triples. This will get distributed evenly across all created triples.
  • Returns uint256[] - Created triples’ vault ID(s)

Implementation​

// useBatchCreateTriple Hook
import { type GetContractReturnType } from 'viem'
import { base } from 'viem/chains'
import { useContractWriteAndWait } from './useContractWriteAndWait'
import { useMultivaultContract } from './useMultivaultContract'

export const useBatchCreateTriple = () => {
  const multivault = useMultivaultContract(
    base.id
  ) as GetContractReturnType

  return useContractWriteAndWait({
    ...multivault,
    functionName: 'createTripleBatch',
  })
}
// Usage Example
const {
  writeAsync: writeBatchCreateTriple,
  awaitingWalletConfirmation,
  awaitingOnChainConfirmation,
} = useBatchCreateTriple()

async function handleBatchCreateTriple(
  subjectIds: string[], 
  predicateIds: string[], 
  objectIds: string[]
) {
  const value = BigInt(tripleValue) * BigInt(subjectIds.length)
  if (!awaitingOnChainConfirmation && !awaitingWalletConfirmation && writeBatchCreateTriple) {
    try {
      const tx = await writeBatchCreateTriple({
        address: MULTIVAULT_CONTRACT_ADDRESS,
        abi: multivaultAbi,
        functionName: 'createTripleBatch',
        args: [
          subjectIds.map(BigInt),
              predicateIds.map(BigInt),
              objectIds.map(BigInt),
        ],
        value: tripleCost * subjectIds.length, // Must be >= minimum creation cost * number of triples
      })
      
      if (tx?.hash) {
        const receipt = await publicClient.waitForTransactionReceipt({
          hash: tx.hash,
        })
        // Handle success
      }
    } catch (error) {
      // Handle error
    }
  }
}

Cost Considerations​

  1. Creation Cost:
    • Minimum ETH required to create a Triple
    • Retrieved via getTripleCost()
    • Includes protocol fee sent to treasury
    • Must be included in transaction's value parameter
  2. Initial Deposit:
    • Any ETH sent above the creation cost
    • Deposited into the positive vault
    • Subject to entry fees

See also: