Getting an error when calling the veramo server agent from another nodeJS repository

[SamSin369]

Getting an error every time I am calling th Veramo Agent from my other server, it works fine when I make the call from the postman.
Been trying to fix it for 2 hours not sure what I am missing

const HEADERS = {
  "Content-Type": "application/json",
  Authorization:
    "Bearer REPLACE_API_KEY",
};

exports.createNewCredential = catchAsync(async (req, res, next) => {
  console.log("hello");
  const instanceId = uuid.v4();

  const { credentialData } = req.body;

  // console.log(credentialData);

  // const credentialToBeIssued = {
  //   credential: {
  //     issuer: {
  //       id: "did:web:veramo-cred-serv-agent.herokuapp.com",
  //     },
  //     credentialSubject: {
  //       id: instanceId,
  //       // ...credentialData,
  //     },
  //     type: ["Non Transferable"],
  //     "@context": ["Elevate Dao early adopter"],
  //     issuanceDate: Date.now(),

  //     credentialStatus: {
  //       id: instanceId,
  //       type: "valid",
  //     },
  //     id: instanceId,
  //   },
  //   proofFormat: "jwt",
  //   removeOriginalFields: true,
  //   fetchRemoteContexts: true,
  // };

  const crdential = {
    credential: {
      issuer: {
        id: "did:web:veramo-update.herokuapp.com",
      },
      credentialSubject: {
        name: "The greatest",
      },
      type: ["test"],
      "@context": ["string"],
      id: "1234",
    },
    proofFormat: "jwt",
    removeOriginalFields: true,
    fetchRemoteContexts: true,
  };

  // console.log(credentialToBeIssued);

  axios
    .post(
      `http://localhost:3332/agent/createVerifiableCredential`,
      crdential,
      HEADERS
    )
    .then((response) => {
      console.log(response);
      // console.log(JSON.stringify(credentialToBeIssued));
      res.status(200).json({
        status: "OK",
        credential: response.data,
      });
    })
    .catch((err) => {
      // console.log(JSON.stringify(credentialToBeIssued));
      console.log(err.message);
      res.status(500).json({
        status: "failed",
        error: err,
      });
    });
});

Here is the tip end of the error

AxiosError: Request failed with status code 401
    at settle (C:\Users\Sam\Veramo_Backend_Chrome\node_modules\axios\dist\node\axios.cjs:1268:12)
    at IncomingMessage.handleStreamEnd (C:\Users\Sam\Veramo_Backend_Chrome\node_modules\axios\dist\node\axios.cjs:2446:11)
    at IncomingMessage.emit (node:events:525:35)
    at endReadableNT (node:internal/streams/readable:1358:12)
    at processTicksAndRejections (node:internal/process/task_queues:83:21) {
  code: 'ERR_BAD_REQUEST',
  config: {
    transitional: {
      silentJSONParsing: true,
      forcedJSONParsing: true,
      clarifyTimeoutError: false
    },
    adapter: [Function: httpAdapter],
    transformRequest: [ [Function: transformRequest] ],
    transformResponse: [ [Function: transformResponse] ],
    timeout: 0,
    xsrfCookieName: 'XSRF-TOKEN',
    xsrfHeaderName: 'X-XSRF-TOKEN',
    maxContentLength: -1,
    maxBodyLength: -1,
    env: { FormData: [Function], Blob: null },
    validateStatus: [Function: validateStatus],
    headers: AxiosHeaders {
      'Content-Type': 'application/json',
      'User-Agent': 'axios/1.1.3',
      'Content-Length': '239',
      'Accept-Encoding': 'gzip, deflate, br',
      [Symbol(defaults)]: [Object]
    },
    'Content-Type': 'application/json',
    Authorization: 'Bearer 700e9323-0140-4d49-b574-e8652fa433ad',
    method: 'post',
    url: 'http://localhost:3332/agent/createVerifiableCredential',
    data: '{"credential":{"issuer":{"id":"did:web:veramo-update.herokuapp.com"},"credentialSubject":{"name":"The greatest"},"type":["test"],"@context":["string"],"id":"1234"},"proofFormat":"jwt","removeOriginalFields":true,"fetchRemoteContexts":true}'
  },

obscuradox — Today at 2:50 PM
Full error

 "error": {
        
            "timeout": 0,
            "xsrfCookieName": "XSRF-TOKEN",
            "xsrfHeaderName": "X-XSRF-TOKEN",
            "maxContentLength": -1,
            "maxBodyLength": -1,
            "env": {
                "Blob": null
            },
            "headers": {
                "Accept": "application/json, text/plain, */*",
                "Content-Type": "application/json",
                "User-Agent": "axios/1.1.3",
                "Content-Length": "239",
                "Accept-Encoding": "gzip, deflate, br"
            },
            "Content-Type": "application/json",
            "Authorization": "Bearer REPLACE_API_KEY",
            "method": "post",
            "url": "http://localhost:3332/agent/createVerifiableCredential",
            "data": "{\"credential\":{\"issuer\":{\"id\":\"did:web:veramo-update.herokuapp.com\"},\"credentialSubject\":{\"name\":\"The greatest\"},\"type\":[\"test\"],\"@context\":[\"string\"],\"id\":\"1234\"},\"proofFormat\":\"jwt\",\"removeOriginalFields\":true,\"fetchRemoteContexts\":true}"
        },
        "code": "ERR_BAD_REQUEST",
        "status": 401
    }

[nickreynolds]

The issue seems to be with the axios.post method. I'm not really sure what the proper arguments are, but here's what I found:

    const crdential = {
        credential: {
        issuer: {
            id: "did:web:veramo-with-explorer.herokuapp.com",
        },
        credentialSubject: {
            name: "The greatest",
        },
        type: ["test"],
        "@context": ["string"],
        id: "1234",
        },
        proofFormat: "jwt",
        removeOriginalFields: true,
        fetchRemoteContexts: true,
    };

    const HEADERS = {
    "Content-Type": "application/json",
    Authorization:
        "Bearer REPLACE_API_KEY",
    };

    const url = `http://veramo-with-explorer.herokuapp.com/agent/createVerifiableCredential`

    // this works
    const fetchResponse = await fetch(url, {method: 'POST', headers: HEADERS, body: JSON.stringify(crdential) })
    console.log("fetchResponse: ", await fetchResponse.json())

    // this fails
    try {
        const axiosResponse = await axios.post(url, JSON.stringify(crdential), HEADERS)
        console.log("axiosResponse: ", axiosResponse)
    } catch (ex) {
        console.error("axios 1 failed: ", ex)
    }
    
    // this works
    try {
        const axiosResponse2 = await axios({url, method: 'POST', data: JSON.stringify(crdential), headers: HEADERS })
        console.log("axiosResponse2: ", axiosResponse2)
    } catch (ex) {
        console.error("axios 2 failed: ", ex)
    }

So, my short term solution would be to use either fetch or the 2nd axios example.

Alternatively, you could try creating a local agent with the RestClient plugin to connect to your remote server so you can use the typescript API:

        const response = await fetch('http://veramo-with-explorer.herokuapp.com/open-api.json')
        const schema = await response.json()
        const agent = createAgent({
            // ...options,
            plugins: [
              new AgentRestClient({
                url: schema.servers[0].url,
                headers: { Authorization: `Bearer ${api_key}` },
                enabledMethods: Object.keys(schema['x-methods']),
                schema,
              }),
            ],
          })
        const res = await agent.createVerifiableCredential({ credential: crdential.credential, proofFormat: 'jwt' })
        console.log("AgentRestClient res: ", res)

[mirceanis]

If you're in a JavaScript environment, it will be much easier to use @veramo/remote-client.

This plugin makes the calls to remote agents and presents those remote methods as local, so your code for interacting with a veramo instance looks the same.

You would create a veramo instance and provide the AgentRestClient plugin from @veramo/remote-client plugin to the plugins param, with the coordinates of the remote agent. Here is an example.

You would then call agent.createVerifiableCredential() as if the agent were a local instance.

The example is from our test suite which runs a bunch of shared tests, using the same test code, in multiple configurations. The configuration I pointed to is one where all plugins are implemented by one agent and called from a different agent.

[mirceanis]

Oh, I just noticed that @nickreynolds already provided an example of this in his very detailed response 😅