fix: use base64url encoding

src/formatter.js

@@ -1,7 +1,7 @@
 import * as UCAN from "./ucan.js"
 import * as DID from "./did.js"
 import * as json from "@ipld/dag-json"
-import { base64urlpad } from "multiformats/bases/base64"
+import { base64url } from "multiformats/bases/base64"
 import { algorithm, ED25519, RSA } from "./did.js"
 
 /**
@@ -26,22 +26,21 @@ export const formatSignPayload = model =>
  * @param {UCAN.Data} data
  * @returns {UCAN.ToString<UCAN.ByteView<UCAN.Header>>}
  */
-export const formatHeader = data => base64urlpad.baseEncode(encodeHeader(data))
+export const formatHeader = data => base64url.baseEncode(encodeHeader(data))
 
 /**
  * @template {UCAN.Capability} C
  * @param {UCAN.Data<C>} data
  * @returns {UCAN.ToString<UCAN.ByteView<UCAN.Payload<C>>>}
  */
-export const formatPayload = data =>
-  base64urlpad.baseEncode(encodePayload(data))
+export const formatPayload = data => base64url.baseEncode(encodePayload(data))
 
 /**
  * @template {UCAN.Capability} C
  * @param {UCAN.Signature<UCAN.SignPayload<C>>} signature
  * @returns {UCAN.ToString<UCAN.Signature<C>>}
  */
-export const formatSignature = signature => base64urlpad.baseEncode(signature)
+export const formatSignature = signature => base64url.baseEncode(signature)
 
 /**
  * @param {UCAN.Data} data

src/parser.js

@@ -1,6 +1,6 @@
 import * as UCAN from "./ucan.js"
 import * as UTF8 from "./utf8.js"
-import { base64urlpad } from "multiformats/bases/base64"
+import { base64url } from "multiformats/bases/base64"
 import * as json from "@ipld/dag-json"
 import { CID } from "multiformats"
 import { identity } from "multiformats/hashes/identity"
@@ -26,15 +26,15 @@ export const parse = input => {
   return {
     ...parseHeader(header),
     ...parsePayload(payload),
-    signature: base64urlpad.baseDecode(signature),
+    signature: base64url.baseDecode(signature),
   }
 }
 
 /**
  * @param {string} header
  */
 export const parseHeader = header => {
-  const { ucv, alg, typ } = json.decode(base64urlpad.baseDecode(header))
+  const { ucv, alg, typ } = json.decode(base64url.baseDecode(header))
 
   const _type = parseJWT(typ)
   const _algorithm = parseAlgorithm(alg)
@@ -50,7 +50,7 @@ export const parseHeader = header => {
  */
 export const parsePayload = input => {
   /** @type {UCAN.Payload<C>} */
-  const payload = json.decode(base64urlpad.baseDecode(input))
+  const payload = json.decode(base64url.baseDecode(input))
 
   return {
     issuer: parseDID(payload.iss, "iss"),

test/compat.spec.js

@@ -0,0 +1,32 @@
+import valid from "./fixtures/0.8.1/valid.js"
+import * as UCAN from "../src/lib.js"
+import { asCapability } from "../src/parser.js"
+import { assert } from "chai"
+import { assertUCAN } from "./util.js"
+import * as DID from "../src/did.js"
+
+const skip = new Set(["Delegated UCAN can delegate"])
+describe("0.8.1", () => {
+  for (const {
+    comment,
+    token,
+    assertions: { header, payload },
+  } of valid) {
+    const test = skip.has(comment) ? it.skip : it
+    test(comment, () => {
+      const ucan = UCAN.parse(token)
+      assertUCAN(ucan, {
+        version: /** @type {UCAN.Version} */ (header.ucv),
+        issuer: DID.parse(/** @type {UCAN.DID} */ (payload.iss)),
+        audience: DID.parse(/** @type {UCAN.DID} */ (payload.aud)),
+        capabilities: payload.att.map(asCapability),
+      })
+
+      const proofs = ucan.proofs.map(cid => UCAN.decode(cid.multihash.digest))
+
+      assert.deepEqual(proofs.map(UCAN.format), payload.prf)
+
+      assert.equal(UCAN.format(ucan), token)
+    })
+  }
+})