Class Agent<S>

constructor

• new Agent<S>(data, options?): Agent<S>

• Type Parameters

  • S extends Record<string, any> = Service

  Parameters

  • data: AgentData

    Agent data

  • Optional options: AgentOptions<S> = {}

  Returns Agent<S>

connection

url

issuer

• get issuer(): Signer<`did:key:${string}`, SigAlg>

• Returns Signer<`did:key:${string}`, SigAlg>

meta

• get meta(): AgentMeta

• Returns AgentMeta

spaces

• get spaces(): Map<`did:${string}:${string}`, SpaceMeta>

• Returns Map<`did:${string}:${string}`, SpaceMeta>

addProof

• addProof(delegation): Promise<{}>

• Add a proof to the agent store.

  Parameters

  • delegation: Delegation<Capabilities>

  Returns Promise<{}>

addProofs

• addProofs(delegations): Promise<{}>

• Adds set of proofs to the agent store.

  Parameters

  • delegations: Iterable<Delegation<Capabilities>>

  Returns Promise<{}>

createSpace

• createSpace(name): Promise<Space.OwnedSpace>

• Creates a space signer and a delegation to the agent

  Parameters

  • name: string

  Returns Promise<Space.OwnedSpace>

currentSpace

• currentSpace(): undefined | `did:key:${string}`

• Get current space DID

  Returns undefined | `did:key:${string}`

currentSpaceWithMeta

• currentSpaceWithMeta(): undefined | {
      capabilities: any[];
      did: `did:key:${string}`;
      meta: undefined | SpaceMeta;
      proofs: Delegation<Capabilities>[];
  }

• Get current space DID, proofs and abilities

  Returns undefined | {
      capabilities: any[];
      did: `did:key:${string}`;
      meta: undefined | SpaceMeta;
      proofs: Delegation<Capabilities>[];
  }

delegate

• delegate(options): Promise<Delegation<Capabilities>>

• Parameters

  • options: DelegationOptions

  Returns Promise<Delegation<Capabilities>>

delegations

• delegations(caps?): Delegation<Capabilities>[]

• Get delegations created by the agent for others.

  Parameters

  • Optional caps: CapabilityQuery[]

    Capabilities to filter by. Empty or undefined caps with return all the delegations.

  Returns Delegation<Capabilities>[]

delegationsWithMeta

• delegationsWithMeta(caps?): {
      delegation: Delegation<Capabilities>;
      meta: DelegationMeta;
  }[]

• Get delegations created by the agent for others and their metadata.

  Parameters

  • Optional caps: CapabilityQuery[]

    Capabilities to filter by. Empty or undefined caps with return all the delegations.

  Returns {
      delegation: Delegation<Capabilities>;
      meta: DelegationMeta;
  }[]

did

• did(): `did:key:${string}`

• Returns `did:key:${string}`

execute

• execute<C, I>(...invocations): Await<InferReceipts<I, S>>

• Execute invocations on the agent's connection

  Type Parameters

  • C extends Capability<Ability, `${string}:${string}`, any>

  • I extends Transport.Tuple<ServiceInvocation<C, S>>

  Parameters

  • Rest ...invocations: I

  Returns Await<InferReceipts<I, S>>

  Example

  const i1 = await agent.invoke(Space.info, {})
  const i2 = await agent.invoke(Space.recover, {
    nb: {
      identity: 'mailto:hello@web3.storage',
    },
  })
  
  const results = await agent.execute2(i1, i2)
  
  Copy

getSpaceInfo

• getSpaceInfo(space?): Promise<SpaceInfoResult>

• Get Space information from Access service

  Parameters

  • Optional space: URI<"did:">

  Returns Promise<SpaceInfoResult>

importSpaceFromDelegation

• importSpaceFromDelegation(delegation, options?): Promise<Space.SharedSpace>

• Import a space from a delegation.

  Parameters

  • delegation: Delegation<Capabilities>

  • options: {
        name: undefined | string;
    } = {}

    • name: undefined | string

  Returns Promise<Space.SharedSpace>

invoke

• invoke<A, R, CAP, C>(cap, options): Promise<IssuedInvocationView<InferInvokedCapability<CAP>>>

• Creates an invocation for the given capability with Agent's proofs, service, issuer and space.

  Type Parameters

  • A extends Ability

  • R extends URI<`${string}:`>

  • CAP extends TheCapabilityParser<CapabilityMatch<A, R, C>>

  • C extends Caveats = {}

  Parameters

  • cap: CAP

  • options: InvokeOptions<A, R, CAP>

  Returns Promise<IssuedInvocationView<InferInvokedCapability<CAP>>>

  Example

  const recoverInvocation = await agent.invoke(Space.recover, {
    nb: {
      identity: 'mailto: email@gmail.com',
    },
  })
  
  await recoverInvocation.execute(agent.connection)
  // or
  await agent.execute(recoverInvocation)
  Copy

invokeAndExecute

• invokeAndExecute<A, R, C>(cap, options): Promise<InferReceipt<Capability<A, R, C>, S>>

• Invoke and execute the given capability on the Access service connection

  
  await agent.invokeAndExecute(Space.recover, {
    nb: {
      identity: 'mailto: email@gmail.com',
    },
  })
  
  // sugar for
  const recoverInvocation = await agent.invoke(Space.recover, {
    nb: {
      identity: 'mailto: email@gmail.com',
    },
  })
  
  await recoverInvocation.execute(agent.connection)
  Copy

  Type Parameters

  • A extends Ability

  • R extends URI<`${string}:`>

  • C extends Caveats

  Parameters

  • cap: TheCapabilityParser<CapabilityMatch<A, R, C>>

  • options: InvokeOptions<A, R, TheCapabilityParser<CapabilityMatch<A, R, C>>>

  Returns Promise<InferReceipt<Capability<A, R, C>, S>>

proofs

• proofs(caps?, options?): Delegation<Capabilities>[]

• Get all the proofs matching the capabilities.

  Proofs are delegations with an audience matching agent DID, or with an audience matching the session DID.

  Proof of session will also be included in the returned proofs if any proofs matching the passed capabilities require it.

  Parameters

  • Optional caps: CapabilityQuery[]

    Capabilities to filter by. Empty or undefined caps with return all the proofs.

  • Optional options: {
        sessionProofIssuer: undefined | `did:${string}:${string}`;
    }

    • sessionProofIssuer: undefined | `did:${string}:${string}`

      only include session proofs for this issuer

  Returns Delegation<Capabilities>[]

recoverSpace

• recoverSpace(secret, options): Promise<Space.OwnedSpace>

• Parameters

  • secret: string

  • options: {
        name: string;
    }

    • name: string

  Returns Promise<Space.OwnedSpace>

removeExpiredDelegations

• removeExpiredDelegations(): Promise<void>

• Clean up any expired delegations.

  Returns Promise<void>

revoke

• revoke(delegationCID, options?): Promise<Schema.Result<{}, Schema.Error | HandlerNotFound | HandlerExecutionError | InvalidAudience | Unauthorized>>

• Revoke a delegation by CID.

  If the delegation was issued by this agent (and therefore is stored in the delegation store) you can just pass the CID. If not, or if the current agent's delegation store no longer contains the delegation, you MUST pass a chain of proofs that proves your authority to revoke this delegation as options.proofs.

  Parameters

  • delegationCID: UCANLink<Capabilities, MulticodecCode<number, string>, SigAlg>

  • Optional options: {
        proofs: undefined | Delegation<Capabilities>[];
    } = {}

    • proofs: undefined | Delegation<Capabilities>[]

  Returns Promise<Schema.Result<{}, Schema.Error | HandlerNotFound | HandlerExecutionError | InvalidAudience | Unauthorized>>

setCurrentSpace

• setCurrentSpace(space): Promise<`did:key:${string}`>

• Sets the current selected space

  Other methods will default to use the current space if no resource is defined

  Parameters

  • space: `did:key:${string}`

  Returns Promise<`did:key:${string}`>

Static create

• create<R>(init?, options?): Promise<Agent<R>>

• Create a new Agent instance, optionally with the passed initialization data.

  Type Parameters

  • R extends Record<string, any> = Service

  Parameters

  • Optional init: Partial<AgentDataModel>

  • Optional options: AgentOptions<R> & AgentDataOptions = {}

  Returns Promise<Agent<R>>

Static from

• from<R>(raw, options?): Agent<R>

• Instantiate an Agent from pre-exported agent data.

  Type Parameters

  • R extends Record<string, any> = Service

  Parameters

  • raw: AgentDataExport

  • Optional options: AgentOptions<R> & AgentDataOptions = {}

  Returns Agent<R>