bridge/app/server/tests/substrate-address.test.ts

/**
 * Tests for SS58 address encoding/decoding.
 *
 * Uses known Polkadot addresses from the Substrate documentation.
 * Run: npx tsx tests/substrate-address.test.ts
 */

import { describe, it } from "node:test"
import assert from "node:assert/strict"
import {
  encodeSubstrateAddress,
  decodeSubstrateAddress,
  isValidSubstrateAddress,
  SUBSTRATE_NETWORKS,
} from "../src/domain/substrate-address.js"

describe("SS58 address encoding", () => {
  // Known test vector: Alice's public key on Polkadot
  // Public key: d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d
  // Polkadot (prefix 0): 15oF4uVJwmo4TdGW7VfQxNLavjCXviqWrztPu7CAkPe19ZSs (but this is actually for generic substrate 42)
  // Let's use a round-trip test instead since exact addresses depend on prefix

  const alicePubKey = new Uint8Array(
    Buffer.from("d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d", "hex")
  )

  it("should encode and decode a Polkadot address (prefix 0)", () => {
    const address = encodeSubstrateAddress(alicePubKey, SUBSTRATE_NETWORKS.POLKADOT)
    assert.ok(address.length > 0, "Address should not be empty")

    const decoded = decodeSubstrateAddress(address)
    assert.equal(decoded.network, 0, "Network should be 0 (Polkadot)")
    assert.deepEqual(decoded.publicKey, alicePubKey, "Public key should round-trip")
  })

  it("should encode and decode a Kusama address (prefix 2)", () => {
    const address = encodeSubstrateAddress(alicePubKey, SUBSTRATE_NETWORKS.KUSAMA)
    assert.ok(address.length > 0, "Address should not be empty")

    const decoded = decodeSubstrateAddress(address)
    assert.equal(decoded.network, 2, "Network should be 2 (Kusama)")
    assert.deepEqual(decoded.publicKey, alicePubKey, "Public key should round-trip")
  })

  it("should encode and decode a generic Substrate address (prefix 42)", () => {
    const address = encodeSubstrateAddress(alicePubKey, SUBSTRATE_NETWORKS.GENERIC)
    assert.ok(address.length > 0, "Address should not be empty")

    const decoded = decodeSubstrateAddress(address)
    assert.equal(decoded.network, 42, "Network should be 42 (generic)")
    assert.deepEqual(decoded.publicKey, alicePubKey, "Public key should round-trip")
  })

  it("should produce different addresses for different networks", () => {
    const polkadot = encodeSubstrateAddress(alicePubKey, SUBSTRATE_NETWORKS.POLKADOT)
    const kusama = encodeSubstrateAddress(alicePubKey, SUBSTRATE_NETWORKS.KUSAMA)
    const generic = encodeSubstrateAddress(alicePubKey, SUBSTRATE_NETWORKS.GENERIC)

    assert.notEqual(polkadot, kusama, "Polkadot and Kusama addresses should differ")
    assert.notEqual(polkadot, generic, "Polkadot and generic addresses should differ")
    assert.notEqual(kusama, generic, "Kusama and generic addresses should differ")
  })

  it("should reject a public key that is not 32 bytes", () => {
    assert.throws(
      () => encodeSubstrateAddress(new Uint8Array(31), 0),
      /Public key must be 32 bytes/,
    )
    assert.throws(
      () => encodeSubstrateAddress(new Uint8Array(33), 0),
      /Public key must be 32 bytes/,
    )
  })

  it("should default to Polkadot (prefix 0) when no network specified", () => {
    const address = encodeSubstrateAddress(alicePubKey)
    const decoded = decodeSubstrateAddress(address)
    assert.equal(decoded.network, 0)
  })
})

describe("SS58 address decoding", () => {
  it("should reject an invalid base58 character", () => {
    assert.throws(
      () => decodeSubstrateAddress("0OIl"),
      /Invalid base58 character/,
    )
  })

  it("should reject a truncated address", () => {
    assert.throws(
      () => decodeSubstrateAddress("1"),
      /SS58/,
    )
  })

  it("should reject an address with a bad checksum", () => {
    const alicePubKey = new Uint8Array(
      Buffer.from("d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d", "hex")
    )
    const address = encodeSubstrateAddress(alicePubKey, 0)

    // Corrupt the last character
    const chars = address.split("")
    const lastChar = chars[chars.length - 1]
    chars[chars.length - 1] = lastChar === "1" ? "2" : "1"
    const corrupted = chars.join("")

    assert.throws(
      () => decodeSubstrateAddress(corrupted),
      /Invalid SS58/,
    )
  })
})

describe("SS58 address validation", () => {
  it("should return true for a valid Polkadot address", () => {
    const alicePubKey = new Uint8Array(
      Buffer.from("d43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d", "hex")
    )
    const address = encodeSubstrateAddress(alicePubKey, 0)
    assert.ok(isValidSubstrateAddress(address))
  })

  it("should return false for garbage", () => {
    assert.ok(!isValidSubstrateAddress("notanaddress"))
    assert.ok(!isValidSubstrateAddress(""))
  })
})

describe("SS58 two-byte prefix", () => {
  it("should handle network prefix >= 64 (two-byte encoding)", () => {
    const pubKey = new Uint8Array(32).fill(0xaa)
    // Network 100 requires two-byte prefix
    const address = encodeSubstrateAddress(pubKey, 100)
    const decoded = decodeSubstrateAddress(address)
    assert.equal(decoded.network, 100)
    assert.deepEqual(decoded.publicKey, pubKey)
  })

  it("should handle network prefix at boundary (63 = one byte, 64 = two bytes)", () => {
    const pubKey = new Uint8Array(32).fill(0xbb)

    const addr63 = encodeSubstrateAddress(pubKey, 63)
    const dec63 = decodeSubstrateAddress(addr63)
    assert.equal(dec63.network, 63)

    const addr64 = encodeSubstrateAddress(pubKey, 64)
    const dec64 = decodeSubstrateAddress(addr64)
    assert.equal(dec64.network, 64)
  })
})