エージェントのミント

1import { mintAndSubmitAgent, mplAgentIdentity } from '@metaplex-foundation/mpl-agent-registry'
2import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
3import { keypairIdentity } from '@metaplex-foundation/umi'
4
5const umi = createUmi('https://api.mainnet-beta.solana.com')
6  .use(mplAgentIdentity())
7
8const keypair = umi.eddsa.createKeypairFromSecretKey(mySecretKeyBytes)
9umi.use(keypairIdentity(keypair))
10
11const result = await mintAndSubmitAgent(umi, {}, {
12  wallet: umi.identity.publicKey,
13  name: 'My AI Agent',
14  uri: 'https://example.com/agent-metadata.json',  // Core asset NFT metadata URI
15  agentMetadata: {                                  // Stored off-chain by the Metaplex API
16    type: 'agent',
17    name: 'My AI Agent',
18    description: 'An autonomous trading agent',
19    services: [
20      { name: 'trading', endpoint: 'https://myagent.ai/trade' },
21    ],
22    registrations: [],
23    supportedTrust: [],
24  },
25})
26
27console.log('Asset address:', result.assetAddress)
28console.log('Transaction signature:', result.signature)
29
30// Asset address: <base58 address>
31// Transaction signature: <base58 signature>

1import {
2  mintAgent,
3  signAndSendAgentTransaction,
4  mplAgentIdentity,
5} from '@metaplex-foundation/mpl-agent-registry'
6import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
7import { keypairIdentity } from '@metaplex-foundation/umi'
8
9const umi = createUmi('https://api.mainnet-beta.solana.com')
10  .use(mplAgentIdentity())
11
12const keypair = umi.eddsa.createKeypairFromSecretKey(mySecretKeyBytes)
13umi.use(keypairIdentity(keypair))
14
15// Step 1: Call the API — returns the unsigned transaction and the pre-computed asset address
16const mintResult = await mintAgent(umi, {}, {
17  wallet: umi.identity.publicKey,
18  name: 'My AI Agent',
19  uri: 'https://example.com/agent-metadata.json',
20  agentMetadata: {
21    type: 'agent',
22    name: 'My AI Agent',
23    description: 'An autonomous trading agent',
24    services: [
25      { name: 'trading', endpoint: 'https://myagent.ai/trade' },
26      { name: 'analysis', endpoint: 'https://myagent.ai/analyze' },
27    ],
28    registrations: [
29      { agentId: 'agent-123', agentRegistry: 'my-registry' },
30    ],
31    supportedTrust: ['tee'],
32  },
33})
34
35console.log('Asset address:', mintResult.assetAddress)
36
37// Step 2: Sign and send using the SDK helper
38const signature = await signAndSendAgentTransaction(umi, mintResult)
39console.log('Confirmed signature:', signature)
40
41// Asset address: <base58 address>
42// Confirmed signature: <base58 signature>

1import { fetchAsset } from '@metaplex-foundation/mpl-core'
2import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
3import { publicKey } from '@metaplex-foundation/umi'
4import { mplAgentIdentity } from '@metaplex-foundation/mpl-agent-registry'
5
6const umi = createUmi('https://api.mainnet-beta.solana.com')
7  .use(mplAgentIdentity())
8
9// Replace with the assetAddress returned by mintAndSubmitAgent or mintAgent
10const assetAddress = publicKey('YOUR_ASSET_ADDRESS')
11const assetData = await fetchAsset(umi, assetAddress)
12const agentIdentity = assetData.agentIdentities?.[0]
13
14console.log('Registration URI:', agentIdentity?.uri)
15console.log('Transfer hook active:', agentIdentity?.lifecycleChecks?.transfer)
16console.log('Update hook active:', agentIdentity?.lifecycleChecks?.update)
17console.log('Execute hook active:', agentIdentity?.lifecycleChecks?.execute)
18
19// Registration URI: https://example.com/agent-metadata.json
20// Transfer hook active: { __kind: 'Listen' }
21// Update hook active: { __kind: 'Listen' }
22// Execute hook active: { __kind: 'Listen' }

1import { mintAndSubmitAgent, mplAgentIdentity } from '@metaplex-foundation/mpl-agent-registry'
2import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
3import { keypairIdentity } from '@metaplex-foundation/umi'
4
5const umi = createUmi('https://api.devnet.solana.com')
6  .use(mplAgentIdentity())
7
8const keypair = umi.eddsa.createKeypairFromSecretKey(mySecretKeyBytes)
9umi.use(keypairIdentity(keypair))
10
11const result = await mintAndSubmitAgent(umi, {}, {
12  wallet: umi.identity.publicKey,
13  network: 'solana-devnet',
14  name: 'Test Agent',
15  uri: 'https://example.com/test-metadata.json',
16  agentMetadata: {
17    type: 'agent',
18    name: 'Test Agent',
19    description: 'A test agent on devnet',
20    services: [],
21    registrations: [],
22    supportedTrust: [],
23  },
24})
25
26console.log('Asset address:', result.assetAddress)
27console.log('Transaction signature:', result.signature)
28
29// Asset address: <base58 address>
30// Transaction signature: <base58 signature>

1import { mintAgent, mplAgentIdentity } from '@metaplex-foundation/mpl-agent-registry'
2import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
3import { keypairIdentity } from '@metaplex-foundation/umi'
4
5const umi = createUmi('https://api.mainnet-beta.solana.com')
6  .use(mplAgentIdentity())
7
8const keypair = umi.eddsa.createKeypairFromSecretKey(mySecretKeyBytes)
9umi.use(keypairIdentity(keypair))
10
11const result = await mintAgent(
12  umi,
13  { baseUrl: 'https://staging-api.metaplex.com' },
14  {
15    wallet: umi.identity.publicKey,
16    name: 'My Agent',
17    uri: 'https://example.com/metadata.json',
18    agentMetadata: {
19      type: 'agent',
20      name: 'My Agent',
21      description: 'Agent targeting staging API',
22      services: [],
23      registrations: [],
24      supportedTrust: [],
25    },
26  }
27)
28
29console.log('Asset address:', result.assetAddress)
30
31// Asset address: <base58 address>

1import { mintAndSubmitAgent, mplAgentIdentity } from '@metaplex-foundation/mpl-agent-registry'
2import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
3import { keypairIdentity } from '@metaplex-foundation/umi'
4
5const umi = createUmi('https://api.mainnet-beta.solana.com')
6  .use(mplAgentIdentity())
7
8const keypair = umi.eddsa.createKeypairFromSecretKey(mySecretKeyBytes)
9umi.use(keypairIdentity(keypair))
10
11const result = await mintAndSubmitAgent(
12  umi,
13  {},
14  {
15    wallet: umi.identity.publicKey,
16    name: 'My Agent',
17    uri: 'https://example.com/metadata.json',
18    agentMetadata: {
19      type: 'agent',
20      name: 'My Agent',
21      description: 'Agent with custom transaction sender',
22      services: [],
23      registrations: [],
24      supportedTrust: [],
25    },
26  },
27  {
28    txSender: async (tx) => {
29      const signed = await umi.identity.signTransaction(tx)
30      return myCustomSend(signed)
31    },
32  }
33)
34
35console.log('Asset address:', result.assetAddress)
36console.log('Transaction signature:', result.signature)
37
38// Asset address: <base58 address>
39// Transaction signature: <base58 signature>

1import {
2  mintAgent,
3  isAgentApiError,
4  isAgentApiNetworkError,
5  isAgentValidationError,
6  mplAgentIdentity,
7} from '@metaplex-foundation/mpl-agent-registry'
8import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
9import { keypairIdentity } from '@metaplex-foundation/umi'
10
11const umi = createUmi('https://api.mainnet-beta.solana.com')
12  .use(mplAgentIdentity())
13
14const keypair = umi.eddsa.createKeypairFromSecretKey(mySecretKeyBytes)
15umi.use(keypairIdentity(keypair))
16
17const input = {
18  wallet: umi.identity.publicKey,
19  name: 'My Agent',
20  uri: 'https://example.com/metadata.json',
21  agentMetadata: {
22    type: 'agent',
23    name: 'My Agent',
24    description: 'An autonomous agent',
25    services: [],
26    registrations: [],
27    supportedTrust: [],
28  },
29}
30
31try {
32  const result = await mintAgent(umi, {}, input)
33} catch (err) {
34  if (isAgentValidationError(err)) {
35    // Client-side validation failed before the API was called
36    console.error(`Validation error on field "${err.field}": ${err.message}`)
37  } else if (isAgentApiNetworkError(err)) {
38    // Could not reach the API endpoint
39    console.error('Network error:', err.message, err.cause)
40  } else if (isAgentApiError(err)) {
41    // API responded with a non-2xx status
42    console.error(`API error (${err.statusCode}): ${err.message}`)
43    console.error('Response body:', err.responseBody)
44  } else {
45    throw err
46  }
47}

1import {
2  mintAndSubmitAgent,
3  mplAgentIdentity,
4} from '@metaplex-foundation/mpl-agent-registry'
5import { fetchAsset } from '@metaplex-foundation/mpl-core'
6import { createUmi } from '@metaplex-foundation/umi-bundle-defaults'
7import { keypairIdentity } from '@metaplex-foundation/umi'
8
9const umi = createUmi('https://api.mainnet-beta.solana.com')
10  .use(mplAgentIdentity())
11
12const keypair = umi.eddsa.createKeypairFromSecretKey(mySecretKeyBytes)
13umi.use(keypairIdentity(keypair))
14
15// 1. Mint the agent
16const result = await mintAndSubmitAgent(umi, {}, {
17  wallet: umi.identity.publicKey,
18  name: 'My AI Agent',
19  uri: 'https://example.com/agent-metadata.json',
20  agentMetadata: {
21    type: 'agent',
22    name: 'My AI Agent',
23    description: 'An autonomous trading agent',
24    services: [
25      { name: 'trading', endpoint: 'https://myagent.ai/trade' },
26    ],
27    registrations: [],
28    supportedTrust: [],
29  },
30})
31
32console.log('Asset address:', result.assetAddress)
33console.log('Tx signature:', result.signature)
34
35// 2. Verify the agent identity was registered
36const assetData = await fetchAsset(umi, result.assetAddress)
37const agentIdentity = assetData.agentIdentities?.[0]
38
39console.log('Registered:', agentIdentity !== undefined)
40console.log('Registration URI:', agentIdentity?.uri)
41
42// Asset address: <base58 address>
43// Tx signature: <base58 signature>
44// Registered: true
45// Registration URI: https://example.com/agent-metadata.json