diff --git a/src/App.tsx b/src/App.tsx
index b7f335c..32076f5 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -28,10 +28,21 @@ import {
 } from "./settings";
 // Imgs
 import metamaskIcon from "./img/metamask-white.png";
-import { RequestStatus, RepoAddresses, Manifest, FormField } from "types";
-import { IPFS_GATEWAY, SDK_INSTALL_URL } from "params";
+import {
+  RequestStatus,
+  RepoAddresses,
+  Manifest,
+  FormField,
+  NetworkId,
+} from "types";
+import {
+  dappnodeKnownDpmRegistries,
+  IPFS_GATEWAY,
+  SDK_INSTALL_URL,
+} from "params";
 import { signRelease } from "utils/signRelease";
 import { fetchReleaseSignature } from "utils/fetchRelease";
+import { publishXDaiTx } from "utils/dpm/publishXDAITx";
 
 const fetchManifestMem = memoizee(fetchManifest, { promise: true });
 const resolveDnpNameMem = memoizee(resolveDnpName, { promise: true });
@@ -82,6 +93,12 @@ export function App() {
   useEffect(() => {
     const urlParams = parseUrlQuery(window.location.search);
     console.log("URL params", urlParams);
+    // r: **repo** human readable ENS dnpName: 'geth.dnp.dappnode.eth'
+    // v: **version** semver version: '0.5.6'
+    // d: **developer address** for new Repo only, address that will control the package: '0xf35960302a07022aba880dffaec2fdd64d5bf1c1'
+    // h: **contentURI** hash for the package:
+    //    - APM: '/ipfs/QmdjrkKfD8ZAA8zHBAFC9y162R52qKcikuVXDNMKMhEsUr'
+    //    - DPM: 'ipfs://QmRAQB6YaCyidP37UdDnjFY5vQuiBrcqdyoW1CuDgwxkD'
     if (urlParams.r) setDnpName(urlParams.r);
     if (urlParams.v) setVersion(urlParams.v);
     if (urlParams.d) setDeveloperAddress(urlParams.d);
@@ -186,7 +203,7 @@ export function App() {
     }
   }
 
-  async function publish() {
+  async function publishMainnet() {
     try {
       if (!dnpName) throw Error("Must provide a dnpName");
       if (!version) throw Error("Must provide a version");
@@ -197,7 +214,7 @@ export function App() {
       if (!provider) throw Error(`Must connect to Metamask first`);
       const network = await provider.getNetwork();
 
-      if (network && String(network.chainId) !== "1")
+      if (network && String(network.chainId) !== NetworkId.Mainnet)
         throw Error("Transactions must be published on Ethereum Mainnet");
 
       const accounts = await provider.listAccounts();
@@ -228,6 +245,29 @@ export function App() {
     }
   }
 
+  async function publishXDAI() {
+    try {
+      if (!dnpName) throw Error("Must provide a dnpName");
+      if (!version) throw Error("Must provide a version");
+      if (!releaseHash) throw Error("Must provide a manifestHash");
+      if (!provider) throw Error(`Must connect to Metamask first`);
+
+      setPublishReqStatus({ loading: true });
+
+      const { txHash } = await publishXDaiTx(
+        { dnpName, version, releaseHash, developerAddress },
+        provider,
+        // TODO: Extend with user provided input
+        dappnodeKnownDpmRegistries
+      );
+
+      setPublishReqStatus({ result: txHash });
+    } catch (e) {
+      console.error(e);
+      setPublishReqStatus({ error: e as Error });
+    }
+  }
+
   /**
    * Description of the input fields
    */
@@ -399,13 +439,22 @@ export function App() {
             {/* Publish button */}
             <div className="bottom-buttons">
               {provider ? (
-                <button
-                  className="btn btn-dappnode"
-                  disabled={publishReqStatus.loading}
-                  onClick={publish}
-                >
-                  Publish
-                </button>
+                <>
+                  <button
+                    className="btn btn-dappnode"
+                    disabled={publishReqStatus.loading}
+                    onClick={publishMainnet}
+                  >
+                    Publish mainnet
+                  </button>
+                  <button
+                    className="btn btn-dappnode"
+                    disabled={publishReqStatus.loading}
+                    onClick={publishXDAI}
+                  >
+                    Publish xDAI
+                  </button>
+                </>
               ) : (
                 <button
                   className="btn btn-dappnode"
diff --git a/src/params.ts b/src/params.ts
index b087028..9b226b1 100644
--- a/src/params.ts
+++ b/src/params.ts
@@ -7,3 +7,9 @@ export const SDK_INSTALL_URL = "https://github.com/dappnode/DAppNodeSDK";
 
 export const signatureFileName = "signature.json";
 export const manifestFileName = "dappnode_package.json";
+
+export const dappnodeKnownDpmRegistries: Record<string, string> = {
+  // EIP-3770: Chain-specific addresses https://eips.ethereum.org/EIPS/eip-3770
+  "dnp.dappnode.eth": "xdai:0x01c58A553F92A61Fd713e6006fa7D1d82044c389",
+  "public.dappnode.eth": "xdai:0xE8addD62feD354203d079926a8e563BC1A7FE81e",
+};
diff --git a/src/types.ts b/src/types.ts
index 33b764e..d7b81e0 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -5,6 +5,42 @@ declare global {
   }
 }
 
+export enum RegistryMode {
+  APM = "APM",
+  DPM = "DPM",
+}
+
+export enum NetworkId {
+  Mainnet = "1",
+  xDAI = "100",
+}
+
+export enum ChainId {
+  Ethereum = "eth",
+  xDAI = "xdai",
+}
+
+/**
+ * EIP-3770: Chain-specific addresses https://eips.ethereum.org/EIPS/eip-3770
+ * ```
+ * xdai:0x01c58A553F92A61Fd713e6006fa7D1d82044c389
+ * ```
+ */
+export type EIP3770AddressStr = string;
+
+/**
+ * EIP-3770: Chain-specific addresses https://eips.ethereum.org/EIPS/eip-3770
+ * ```
+ * xdai:0x01c58A553F92A61Fd713e6006fa7D1d82044c389
+ * ```
+ */
+export type EIP3770Address = {
+  /** `xdai` */
+  chainId: string;
+  /** `0x01c58A553F92A61Fd713e6006fa7D1d82044c389` */
+  address: string;
+};
+
 export interface RequestStatus<R = unknown> {
   result?: R;
   loading?: boolean;
diff --git a/src/utils/dpm/checkPermissions.ts b/src/utils/dpm/checkPermissions.ts
new file mode 100644
index 0000000..34b5c0d
--- /dev/null
+++ b/src/utils/dpm/checkPermissions.ts
@@ -0,0 +1,83 @@
+import { ethers } from "ethers";
+import { registryAbi } from "./registryAbi";
+import { repoAbi } from "./repoAbi";
+
+export type DmpStatus =
+  | {
+      repoExists: true;
+      repoAddress: string;
+    }
+  | {
+      repoExists: false;
+      registryAddress: string;
+    };
+
+/**
+ * - Check registry exists
+ * - Check registry name matches
+ * - Check if repo is published
+ * - Check if address has permissions for Repo
+ * - Check if address has permissions for Registry
+ */
+export async function checkDpmPermissions(
+  registryName: string,
+  registryAddress: string,
+  repoName: string,
+  userAddress: string,
+  provider: ethers.providers.Provider
+): Promise<DmpStatus> {
+  const registry = new ethers.Contract(registryAddress, registryAbi, provider);
+
+  let actualRegistryName: string;
+  try {
+    actualRegistryName = await registry.registryName();
+  } catch (e) {
+    (e as Error).message = `Registry ${registryAddress} not found: ${
+      (e as Error).message
+    }`;
+    throw e;
+  }
+
+  if (actualRegistryName !== registryName) {
+    throw Error(
+      `Registry at address ${registryAddress} has registryName ${actualRegistryName} instead of expected ${registryName}`
+    );
+  }
+
+  const registryPackage = await registry.getPackage(repoName).catch(() => null);
+
+  if (registryPackage === null) {
+    // Package not published
+
+    const ADD_PACKAGE_ROLE = await registry.ADD_PACKAGE_ROLE();
+    const hasRole = await registry.hasRole(ADD_PACKAGE_ROLE, userAddress);
+
+    if (!hasRole) {
+      throw Error(
+        `Address ${userAddress} not allowed to publish to registry ${registryName}`
+      );
+    }
+
+    return {
+      repoExists: false,
+      registryAddress,
+    };
+  } else {
+    // Package published
+
+    const repoAddress = registryPackage.repo;
+    const repo = new ethers.Contract(repoAddress, repoAbi, provider);
+    const CREATE_VERSION_ROLE = await repo.CREATE_VERSION_ROLE();
+    const hasRole = await repo.hasRole(CREATE_VERSION_ROLE, userAddress);
+
+    if (!hasRole) {
+      throw Error(
+        `Address ${userAddress} not allowed to publish to repo ${repoName}`
+      );
+    }
+    return {
+      repoExists: true,
+      repoAddress,
+    };
+  }
+}
diff --git a/src/utils/dpm/executeDpmPublishTx.ts b/src/utils/dpm/executeDpmPublishTx.ts
new file mode 100644
index 0000000..71fa4b1
--- /dev/null
+++ b/src/utils/dpm/executeDpmPublishTx.ts
@@ -0,0 +1,73 @@
+import { ethers } from "ethers";
+import { registryAbi } from "./registryAbi";
+import { repoAbi } from "./repoAbi";
+import { DmpStatus } from "./checkPermissions";
+import { parseDpmDnpName } from "./utils";
+import { normalizeIpfsPath } from "utils/isIpfsHash";
+
+export async function executeDpmPublishTx(
+  status: DmpStatus,
+  {
+    dnpName,
+    version,
+    manifestHash,
+    developerAddress,
+  }: {
+    dnpName: string;
+    version: string;
+    manifestHash: string;
+    developerAddress?: string;
+  },
+  provider: ethers.providers.Web3Provider
+) {
+  if (!dnpName) throw Error("dnpName must be defined");
+  if (!version) throw Error("version must be defined");
+  if (!manifestHash) throw Error("manifestHash must be defined");
+
+  const signer = provider.getSigner();
+
+  // Compute tx data
+  // contentURI in ENSIP-7 format
+  const ipfsHash = normalizeIpfsPath(manifestHash);
+  const contentURI = "ipfs://" + ipfsHash;
+
+  let unsignedTx: ethers.PopulatedTransaction;
+  // If repository exists, push new version to it
+  if (status.repoExists) {
+    const repo = new ethers.Contract(status.repoAddress, repoAbi, signer);
+    unsignedTx = await repo.populateTransaction.newVersion(
+      version, // string _version
+      [contentURI] // string[] _contentURIs
+    );
+  }
+
+  // If repo does not exist, create a new repo and push version
+  else {
+    // A developer address can be provided by the option developerAddress.
+    // If it is not provided a prompt will ask for it
+
+    const { repoName } = parseDpmDnpName(dnpName);
+
+    if (!developerAddress)
+      throw Error("developerAddress must be defined for new repos");
+
+    // TODO: Ask user for flags if repo allows customizing those
+    const defaultFlags = 0b000;
+
+    const registry = new ethers.Contract(
+      status.registryAddress,
+      registryAbi,
+      signer
+    );
+    unsignedTx = await registry.populateTransaction.newPackageWithVersion(
+      repoName, // string _name
+      developerAddress, // address _dev
+      defaultFlags, // uint8 flags
+      version, // string _version
+      [contentURI] // string[] _contentURIs
+    );
+  }
+
+  const txResponse = await signer.sendTransaction(unsignedTx);
+  return txResponse.hash;
+}
diff --git a/src/utils/dpm/publishXDAITx.ts b/src/utils/dpm/publishXDAITx.ts
new file mode 100644
index 0000000..b2044ba
--- /dev/null
+++ b/src/utils/dpm/publishXDAITx.ts
@@ -0,0 +1,67 @@
+import { ethers } from "ethers";
+import { ChainId, NetworkId } from "types";
+import { checkDpmPermissions } from "./checkPermissions";
+import { executeDpmPublishTx } from "./executeDpmPublishTx";
+import { parseDpmDnpName, parseEIP3770Address } from "./utils";
+
+export async function publishXDaiTx(
+  {
+    dnpName,
+    version,
+    releaseHash,
+    developerAddress,
+  }: {
+    dnpName: string;
+    version: string;
+    releaseHash: string;
+    developerAddress?: string;
+  },
+  provider: ethers.providers.Web3Provider,
+  dpmRegistries: Record<string, string>
+): Promise<{ txHash: string }> {
+  // Resolve registry and its network from the name
+  const { repoName, registryName } = parseDpmDnpName(dnpName);
+
+  const registryEIP3770Address = dpmRegistries[registryName];
+  if (!registryEIP3770Address) {
+    throw Error(`Unknown registry ${registryName}`);
+  }
+
+  const { chainId, address: registryAddress } = parseEIP3770Address(
+    registryEIP3770Address
+  );
+
+  const network = await provider.getNetwork();
+
+  if (String(network.chainId) !== NetworkId.xDAI)
+    throw Error(
+      `Must connect to xDAI network, current networkID: ${network.chainId}`
+    );
+
+  if (chainId !== ChainId.xDAI) {
+    throw Error(`Registry chainID ${chainId} not supported`);
+  }
+
+  const accounts = await provider.listAccounts();
+  const userAddress = accounts[0];
+
+  if (!userAddress) {
+    throw Error("provider.listAccounts returned an empty list");
+  }
+
+  const dmpStatus = await checkDpmPermissions(
+    registryName,
+    registryAddress,
+    repoName,
+    userAddress,
+    provider
+  );
+
+  const txHash = await executeDpmPublishTx(
+    dmpStatus,
+    { dnpName, version, manifestHash: releaseHash, developerAddress },
+    provider
+  );
+
+  return { txHash };
+}
diff --git a/src/utils/dpm/registry.ts b/src/utils/dpm/registry.ts
new file mode 100644
index 0000000..0bf3ca2
--- /dev/null
+++ b/src/utils/dpm/registry.ts
@@ -0,0 +1,170 @@
+import { ethers } from "ethers";
+import { registryAbi } from "./registryAbi";
+
+type AddressHex = string;
+
+/**
+ * @dev Bitfield with status flags, TBD
+ * - 0: visible: Display in a public list. Can be set to false for early stage
+ *      packages or while testing.
+ * - 1: validated: The quality of this package has been validated. Useful for a
+ *      governing authority to attest the package.
+ * - 2: banned: This package is damaging in some way and must not be installed
+ *      nor showed. Useful for a governing authority to attest the package and
+ *      override `visible` which may be controlled by the developer.
+ */
+export enum Flags {
+  visible = "visible",
+  validated = "validated",
+  banned = "banned"
+}
+
+export type Package = {
+  repoAddress: string;
+  repoName: string;
+  flags: Record<Flags, boolean>;
+};
+
+/** Repo contract struct type */
+type PackageDpm = {
+  flags: number;
+  repo: string;
+  name: string;
+};
+
+/**
+ * Fetch all packages
+ * If provided version request range, only returns satisfying versions
+ * @param dnpName "bitcoin.dnp.dappnode.eth"
+ */
+export async function fetchDpmRegistryPackages(
+  provider: ethers.providers.Provider,
+  registryAddress: AddressHex
+): Promise<{ packages: Package[]; packageList: number[] }> {
+  const registry = new ethers.Contract(registryAddress, registryAbi, provider);
+
+  // Fetch packages
+
+  // function getPackageCount() public view returns (uint256)
+  const packageCountBn = await registry.getPackageCount();
+  const packageCount = packageCountBn.toNumber();
+
+  // Versions called by id are ordered in ascending order.
+  // The min version = 1 and the latest = versionCount
+  const indexes: number[] = [];
+  for (let i = 1; i <= packageCount; i++) {
+    indexes.push(i);
+  }
+
+  const packages: PackageDpm[] = await Promise.all(
+    // mapping(uint256 => Package) public packages
+    indexes.map(index => registry.packages(index))
+  );
+
+  // Fetch list
+
+  /**
+   * @dev Bytes per list item in packed bytes `packageList`.
+   * Refer to `packageList` for examples
+   */
+  // uint64 public bytesPerListItem;
+  const bytesPerListItemBn = await registry.bytesPerListItem();
+
+  /**
+   * @dev Compact list of packageIdx'es in some order. This list may signal
+   * ordering for quality, relevance, etc.
+   *
+   * For example, to represent the list [1,2]:
+   * | bytesPerListItem | packageList |
+   * | ---------------- | ----------- |
+   * | 1                | 0x0102      |
+   * | 2                | 0x00010002  |
+   *
+   * This allows to support very big registries while keeping small lists cheap.
+   */
+  // bytes public packageList;
+  const packageListHex = await registry.packageList();
+
+  const bytesPerListItem = bytesPerListItemBn.toNumber();
+  const packageList = parsePackageListHex(packageListHex, bytesPerListItem);
+
+  return {
+    packages: packages.map(pkg => ({
+      flags: parseFlags(pkg.flags),
+      // Drop array index keys from ethers
+      repoAddress: pkg.repo,
+      repoName: pkg.name
+    })),
+    packageList
+  };
+}
+
+export async function fetchDpmRegistryPackage(
+  provider: ethers.providers.Provider,
+  registryAddress: AddressHex,
+  packageName: string
+): Promise<Package> {
+  const registry = new ethers.Contract(registryAddress, registryAbi, provider);
+
+  // function getPackage(string memory _name) public view returns (Package memory)
+  const pkg = (await registry.getPackage(packageName)) as PackageDpm;
+  // Drop array index keys from ethers
+  return {
+    flags: parseFlags(pkg.flags),
+    repoAddress: pkg.repo,
+    repoName: pkg.name
+  };
+}
+
+export function parsePackageListHex(
+  packageListHex: string,
+  bytesPerListItem: number
+): number[] {
+  if (packageListHex.startsWith("0x")) packageListHex = packageListHex.slice(2);
+
+  const indexes: number[] = [];
+  const listLen = Math.ceil(packageListHex.length / bytesPerListItem / 2);
+
+  for (let i = 0; i < listLen; i++) {
+    const indexHex = packageListHex.slice(
+      i * 2 * bytesPerListItem,
+      (i + 1) * 2 * bytesPerListItem
+    );
+    const index = parseInt(indexHex, 16);
+    indexes.push(index);
+  }
+
+  return indexes;
+}
+
+export function parseFlags(flags: number): Record<Flags, boolean> {
+  return {
+    visible: (flags & 1) === 1,
+    validated: (flags & 2) === 2,
+    banned: (flags & 4) === 4
+  };
+}
+
+export function sortWithPackageList<T>(
+  packageList: number[],
+  values: T[]
+): T[] {
+  const valuesSorted: typeof values = [];
+
+  // First push the packages listed in packageList
+  for (const index of packageList) {
+    if (index < values.length) {
+      valuesSorted.push(values[index]);
+    }
+  }
+
+  // Then push the rest of packages expect the already pushed
+  const packageListSet = new Set(packageList);
+  for (let i = 0; i < values.length; i++) {
+    if (!packageListSet.has(i)) {
+      valuesSorted.push(values[i]);
+    }
+  }
+
+  return valuesSorted;
+}
diff --git a/src/utils/dpm/registryAbi.ts b/src/utils/dpm/registryAbi.ts
new file mode 100644
index 0000000..27d2dab
--- /dev/null
+++ b/src/utils/dpm/registryAbi.ts
@@ -0,0 +1,716 @@
+export const registryAbi = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "packageIdx",
+        type: "uint256",
+      },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "name",
+        type: "string",
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "repo",
+        type: "address",
+      },
+    ],
+    name: "AddPackage",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "previousAdminRole",
+        type: "bytes32",
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "newAdminRole",
+        type: "bytes32",
+      },
+    ],
+    name: "RoleAdminChanged",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "account",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "sender",
+        type: "address",
+      },
+    ],
+    name: "RoleGranted",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "account",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "sender",
+        type: "address",
+      },
+    ],
+    name: "RoleRevoked",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "packageIdx",
+        type: "uint256",
+      },
+      {
+        indexed: false,
+        internalType: "address",
+        name: "repo",
+        type: "address",
+      },
+    ],
+    name: "UpdateRepo",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "packageIdx",
+        type: "uint256",
+      },
+      {
+        indexed: false,
+        internalType: "uint64",
+        name: "flags",
+        type: "uint64",
+      },
+    ],
+    name: "UpdateStatus",
+    type: "event",
+  },
+  {
+    inputs: [],
+    name: "ADD_PACKAGE_ROLE",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "DEFAULT_ADMIN_ROLE",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "SET_LIST_ROLE",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "SET_REPO_ROLE",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "SET_STATUS_ROLE",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "_name",
+        type: "string",
+      },
+      {
+        internalType: "address",
+        name: "_repo",
+        type: "address",
+      },
+      {
+        internalType: "uint64",
+        name: "flags",
+        type: "uint64",
+      },
+    ],
+    name: "addPackage",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "addPackageAnyAddress",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "bytesPerListItem",
+    outputs: [
+      {
+        internalType: "uint64",
+        name: "",
+        type: "uint64",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "_name",
+        type: "string",
+      },
+    ],
+    name: "getPackage",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint64",
+            name: "flags",
+            type: "uint64",
+          },
+          {
+            internalType: "address",
+            name: "repo",
+            type: "address",
+          },
+          {
+            internalType: "string",
+            name: "name",
+            type: "string",
+          },
+        ],
+        internalType: "struct Registry.Package",
+        name: "",
+        type: "tuple",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "getPackageCount",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "_name",
+        type: "string",
+      },
+    ],
+    name: "getPackageIdx",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+    ],
+    name: "getRoleAdmin",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+      {
+        internalType: "uint256",
+        name: "index",
+        type: "uint256",
+      },
+    ],
+    name: "getRoleMember",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+    ],
+    name: "getRoleMemberCount",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+      {
+        internalType: "address",
+        name: "account",
+        type: "address",
+      },
+    ],
+    name: "grantRole",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+      {
+        internalType: "address",
+        name: "account",
+        type: "address",
+      },
+    ],
+    name: "hasRole",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "_registryName",
+        type: "string",
+      },
+    ],
+    name: "initialize",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "_name",
+        type: "string",
+      },
+      {
+        internalType: "address",
+        name: "_dev",
+        type: "address",
+      },
+      {
+        internalType: "uint64",
+        name: "_flags",
+        type: "uint64",
+      },
+    ],
+    name: "newPackage",
+    outputs: [
+      {
+        internalType: "contract Repo",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "_name",
+        type: "string",
+      },
+      {
+        internalType: "address",
+        name: "_dev",
+        type: "address",
+      },
+      {
+        internalType: "uint64",
+        name: "flags",
+        type: "uint64",
+      },
+      {
+        internalType: "string",
+        name: "_version",
+        type: "string",
+      },
+      {
+        internalType: "string[]",
+        name: "_contentURIs",
+        type: "string[]",
+      },
+    ],
+    name: "newPackageWithVersion",
+    outputs: [
+      {
+        internalType: "contract Repo",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32",
+      },
+    ],
+    name: "packageIdxByName",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "packageList",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    name: "packages",
+    outputs: [
+      {
+        internalType: "uint64",
+        name: "flags",
+        type: "uint64",
+      },
+      {
+        internalType: "address",
+        name: "repo",
+        type: "address",
+      },
+      {
+        internalType: "string",
+        name: "name",
+        type: "string",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "registryName",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+      {
+        internalType: "address",
+        name: "account",
+        type: "address",
+      },
+    ],
+    name: "renounceRole",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "repoImplementation",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+      {
+        internalType: "address",
+        name: "account",
+        type: "address",
+      },
+    ],
+    name: "revokeRole",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bool",
+        name: "_addPackageAnyAddress",
+        type: "bool",
+      },
+    ],
+    name: "setAddPackageAnyAddress",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "_packageList",
+        type: "bytes",
+      },
+      {
+        internalType: "uint64",
+        name: "_bytesPerListItem",
+        type: "uint64",
+      },
+    ],
+    name: "setList",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "packageIdx",
+        type: "uint256",
+      },
+      {
+        internalType: "address",
+        name: "repo",
+        type: "address",
+      },
+    ],
+    name: "setPackageRepo",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "packageIdx",
+        type: "uint256",
+      },
+      {
+        internalType: "uint64",
+        name: "flags",
+        type: "uint64",
+      },
+    ],
+    name: "setPackageStatus",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "interfaceId",
+        type: "bytes4",
+      },
+    ],
+    name: "supportsInterface",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+];
diff --git a/src/utils/dpm/repo.ts b/src/utils/dpm/repo.ts
new file mode 100644
index 0000000..4cd4927
--- /dev/null
+++ b/src/utils/dpm/repo.ts
@@ -0,0 +1,138 @@
+import { ethers } from "ethers";
+import semver from "semver";
+import { repoAbi } from "./repoAbi";
+
+type AddressHex = string;
+
+export type VersionDpm = {
+  /** `'1.0.1'` */
+  version: string;
+  /** `'ipfs://Qmc3Kt4BuM84kEy3ojZMKXjSDPi1HNu8m5tyDvW9KaKaYu'` */
+  contentURIs: string[];
+};
+
+export type VersionDpmWithId = VersionDpm & {
+  /** Version ID in Repo contract. Min version has id = 1 */
+  id: number;
+};
+
+export enum VersionSorting {
+  semver = 0,
+  alphabetical = 1
+}
+
+/**
+ * Fetch versions of a DPM from `lastVersionId`. Note that the first version has id = 1.
+ * Versions are immutable and only new versions can be added. Versions are safe to cache,
+ * after considering re-orgs.
+ */
+export async function fetchDpmRepoVersions(
+  provider: ethers.providers.Provider,
+  repoAddress: AddressHex,
+  prevVersionCount = 0
+): Promise<VersionDpmWithId[]> {
+  const repo = new ethers.Contract(repoAddress, repoAbi, provider);
+
+  // function getVersionsCount() public view returns (uint256)
+  const versionCountBn = await repo.getVersionsCount();
+  const versionCount = versionCountBn.toNumber();
+
+  if (prevVersionCount === versionCount) {
+    return [];
+  }
+
+  // Versions called by id are ordered in ascending order.
+  // The min version = 1 and the latest = versionCount
+  const ids: number[] = [];
+  for (let i = prevVersionCount + 1; i <= versionCount; i++) {
+    ids.push(i);
+  }
+
+  // function getByVersionId(uint256 _versionId) public view returns (Version memory)
+  return await Promise.all(
+    ids.map(async id => {
+      const version = (await repo.getByVersionId(id)) as VersionDpm;
+      return { id, ...parseVersionDpm(version) };
+    })
+  );
+}
+
+/**
+ * Fetch a specific version of a DPM.
+ */
+export async function fetchDpmRepoVersion(
+  provider: ethers.providers.Provider,
+  repoAddress: AddressHex,
+  versionStr: string
+): Promise<VersionDpm> {
+  const repo = new ethers.Contract(repoAddress, repoAbi, provider);
+
+  // function getBySemanticVersion(string memory _version) public view returns (Version memory)
+  const version = (await repo.getBySemanticVersion(versionStr)) as VersionDpm;
+  return parseVersionDpm(version);
+}
+
+/**
+ * Fetch the last published version. Does not mean LATEST in semver terms
+ */
+export async function fetchDnpRepoLastPublishedVersion(
+  provider: ethers.providers.Provider,
+  repoAddress: AddressHex
+): Promise<VersionDpm> {
+  const repo = new ethers.Contract(repoAddress, repoAbi, provider);
+
+  // function getLastPublished() public view returns (Version memory)
+  const version = (await repo.getLastPublished()) as VersionDpm;
+  return parseVersionDpm(version);
+}
+
+export async function fetchDnpRepoVersionSorting(
+  provider: ethers.providers.Provider,
+  repoAddress: AddressHex
+): Promise<VersionSorting> {
+  const repo = new ethers.Contract(repoAddress, repoAbi, provider);
+
+  // uint256 public versionSorting;
+  const versionSortingBn = await repo.versionSorting();
+  const versionSorting = versionSortingBn.toNumber();
+
+  if (VersionSorting[versionSorting] === undefined) {
+    throw Error(`Unknown version sorting ${versionSorting}`);
+  }
+
+  return versionSorting;
+}
+
+function parseVersionDpm(version: VersionDpm): VersionDpm {
+  if (version.version === undefined) {
+    throw Error("no version.version property");
+  }
+  if (version.contentURIs === undefined) {
+    throw Error("no version.contentURIs property");
+  }
+
+  // Drop extra properties from ethers value return
+  return {
+    version: version.version,
+    contentURIs: version.contentURIs
+  };
+}
+
+export function sortLatestVersion(
+  versionSorting: VersionSorting,
+  versionsStrs: string[]
+): string {
+  switch (versionSorting) {
+    case VersionSorting.semver: {
+      const versionStrSorted = versionsStrs.sort((a, b) =>
+        semver.rcompare(a, b, { loose: true, includePrerelease: true })
+      );
+      return versionStrSorted[0];
+    }
+
+    case VersionSorting.alphabetical: {
+      const versionStrSorted = versionsStrs.sort((a, b) => b.localeCompare(a));
+      return versionStrSorted[0];
+    }
+  }
+}
diff --git a/src/utils/dpm/repoAbi.ts b/src/utils/dpm/repoAbi.ts
new file mode 100644
index 0000000..d14f29f
--- /dev/null
+++ b/src/utils/dpm/repoAbi.ts
@@ -0,0 +1,487 @@
+export const repoAbi = [
+  {
+    inputs: [],
+    stateMutability: "nonpayable",
+    type: "constructor",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "versionId",
+        type: "uint256",
+      },
+      {
+        indexed: false,
+        internalType: "string",
+        name: "version",
+        type: "string",
+      },
+      {
+        indexed: false,
+        internalType: "string[]",
+        name: "contentURIs",
+        type: "string[]",
+      },
+    ],
+    name: "NewVersion",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "previousAdminRole",
+        type: "bytes32",
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "newAdminRole",
+        type: "bytes32",
+      },
+    ],
+    name: "RoleAdminChanged",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "account",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "sender",
+        type: "address",
+      },
+    ],
+    name: "RoleGranted",
+    type: "event",
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "account",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "sender",
+        type: "address",
+      },
+    ],
+    name: "RoleRevoked",
+    type: "event",
+  },
+  {
+    inputs: [],
+    name: "CREATE_VERSION_ROLE",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "DEFAULT_ADMIN_ROLE",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "_version",
+        type: "string",
+      },
+    ],
+    name: "getBySemanticVersion",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "string",
+            name: "version",
+            type: "string",
+          },
+          {
+            internalType: "string[]",
+            name: "contentURIs",
+            type: "string[]",
+          },
+        ],
+        internalType: "struct Repo.Version",
+        name: "",
+        type: "tuple",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_versionId",
+        type: "uint256",
+      },
+    ],
+    name: "getByVersionId",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "string",
+            name: "version",
+            type: "string",
+          },
+          {
+            internalType: "string[]",
+            name: "contentURIs",
+            type: "string[]",
+          },
+        ],
+        internalType: "struct Repo.Version",
+        name: "",
+        type: "tuple",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "getLastPublished",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "string",
+            name: "version",
+            type: "string",
+          },
+          {
+            internalType: "string[]",
+            name: "contentURIs",
+            type: "string[]",
+          },
+        ],
+        internalType: "struct Repo.Version",
+        name: "",
+        type: "tuple",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+    ],
+    name: "getRoleAdmin",
+    outputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+      {
+        internalType: "uint256",
+        name: "index",
+        type: "uint256",
+      },
+    ],
+    name: "getRoleMember",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+    ],
+    name: "getRoleMemberCount",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "getVersionsCount",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+      {
+        internalType: "address",
+        name: "account",
+        type: "address",
+      },
+    ],
+    name: "grantRole",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+      {
+        internalType: "address",
+        name: "account",
+        type: "address",
+      },
+    ],
+    name: "hasRole",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "_admin",
+        type: "address",
+      },
+    ],
+    name: "initialize",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "_version",
+        type: "string",
+      },
+      {
+        internalType: "string[]",
+        name: "_contentURIs",
+        type: "string[]",
+      },
+    ],
+    name: "newVersion",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+      {
+        internalType: "address",
+        name: "account",
+        type: "address",
+      },
+    ],
+    name: "renounceRole",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "role",
+        type: "bytes32",
+      },
+      {
+        internalType: "address",
+        name: "account",
+        type: "address",
+      },
+    ],
+    name: "revokeRole",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "_versionSorting",
+        type: "uint256",
+      },
+    ],
+    name: "setVersionSorting",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "interfaceId",
+        type: "bytes4",
+      },
+    ],
+    name: "supportsInterface",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32",
+      },
+    ],
+    name: "versionIdForSemantic",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [],
+    name: "versionSorting",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256",
+      },
+    ],
+    name: "versions",
+    outputs: [
+      {
+        internalType: "string",
+        name: "version",
+        type: "string",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+];
diff --git a/src/utils/dpm/utils.ts b/src/utils/dpm/utils.ts
new file mode 100644
index 0000000..d47d7eb
--- /dev/null
+++ b/src/utils/dpm/utils.ts
@@ -0,0 +1,36 @@
+import { EIP3770Address, EIP3770AddressStr } from "../../types";
+
+export function parseEIP3770Address(
+  eip3770AddressStr: EIP3770AddressStr
+): EIP3770Address {
+  // EIP-3770: Chain-specific addresses https://eips.ethereum.org/EIPS/eip-3770
+  // xdai:0x01c58A553F92A61Fd713e6006fa7D1d82044c389
+  const chrIdx = eip3770AddressStr.indexOf(":");
+  if (chrIdx < 0) {
+    throw Error(`Invalid EIP-3770 address no ':' ${eip3770AddressStr}`);
+  }
+
+  const chainId = eip3770AddressStr.slice(0, chrIdx);
+  const address = eip3770AddressStr.slice(chrIdx + 1);
+
+  return { chainId, address };
+}
+
+/**
+ * @param dnpName 'geth.dnp.dappnode.eth'
+ * @returns 'geth' / 'dnp.dappnode.eth'
+ */
+export function parseDpmDnpName(dnpName: string): {
+  repoName: string;
+  registryName: string;
+} {
+  const dotIdx = dnpName.indexOf(".");
+  if (dotIdx < 0) {
+    throw Error(`Invalid dnpName ${dnpName} must contain the '.' character`);
+  }
+
+  const repoName = dnpName.slice(0, dotIdx);
+  const registryName = dnpName.slice(dotIdx + 1);
+
+  return { repoName, registryName };
+}
diff --git a/src/utils/fetchRelease.ts b/src/utils/fetchRelease.ts
index 62bd229..8311a13 100644
--- a/src/utils/fetchRelease.ts
+++ b/src/utils/fetchRelease.ts
@@ -1,11 +1,11 @@
 import { signatureFileName } from "params";
-import { parseIpfsPath } from "./isIpfsHash";
+import { normalizeIpfsPath } from "./isIpfsHash";
 
 export async function fetchReleaseSignature(
   hash: string,
   IPFS_GATEWAY: string
 ): Promise<string> {
-  hash = parseIpfsPath(hash);
+  hash = normalizeIpfsPath(hash);
 
   const res = await fetch(`${IPFS_GATEWAY}/ipfs/${hash}/${signatureFileName}`);
 
diff --git a/src/utils/isIpfsHash.ts b/src/utils/isIpfsHash.ts
index 36ee9f6..164b0bd 100644
--- a/src/utils/isIpfsHash.ts
+++ b/src/utils/isIpfsHash.ts
@@ -1,15 +1,39 @@
 // @ts-ignore // No type definitions for "is-ipfs"
 import isIPFS from "is-ipfs";
+import { RegistryMode } from "types";
 
-function isMultihash(hash: string) {
-  return isIPFS.cid(hash);
+const ipfsPathPrefixes = ["ipfs/", "/ipfs/", "ipfs://"];
+
+/**
+ * @param contentURI
+ * - APM: '/ipfs/QmdjrkKfD8ZAA8zHBAFC9y162R52qKcikuVXDNMKMhEsUr'
+ * - DPM: 'ipfs://QmRAQB6YaCyidP37UdDnjFY5vQuiBrcqdyoW1CuDgwxkD'
+ * @returns 'QmdjrkKfD8ZAA8zHBAFC9y162R52qKcikuVXDNMKMhEsUr'
+ */
+export function normalizeIpfsPath(contentURI: string): string {
+  for (const prefix of ipfsPathPrefixes) {
+    if (contentURI.startsWith(prefix)) {
+      return contentURI.split(prefix)[1];
+    }
+  }
+
+  return contentURI;
 }
 
-export function parseIpfsPath(hash: string): string {
-  if (hash.includes("ipfs/")) {
-    hash = hash.split("ipfs/")[1];
+export function formatContentURI(
+  ipfsHash: string,
+  registryMode: RegistryMode
+): string {
+  switch (registryMode) {
+    case RegistryMode.APM:
+      return `/ipfs/${ipfsHash}`;
+    case RegistryMode.DPM:
+      return `ipfs://${ipfsHash}`;
   }
-  return hash;
+}
+
+function isMultihash(hash: string) {
+  return isIPFS.cid(hash);
 }
 
 /**
@@ -24,7 +48,7 @@ export function parseIpfsPath(hash: string): string {
 export function isIpfsHash(hash: string): boolean {
   if (!hash || typeof hash !== "string") return false;
   // Correct hash prefix
-  hash = parseIpfsPath(hash);
+  hash = normalizeIpfsPath(hash);
   hash.replace("/", "");
   // Make sure hash if valid
   return isMultihash(hash);
diff --git a/src/utils/signRelease.ts b/src/utils/signRelease.ts
index a4121a2..a580c37 100644
--- a/src/utils/signRelease.ts
+++ b/src/utils/signRelease.ts
@@ -5,7 +5,7 @@ import { base64, base64url } from "multiformats/bases/base64";
 import { ethers } from "ethers";
 import sortBy from "lodash/sortBy";
 import { signatureFileName } from "params";
-import { parseIpfsPath } from "./isIpfsHash";
+import { normalizeIpfsPath } from "./isIpfsHash";
 
 export async function signRelease(
   releaseHash: string,
@@ -19,7 +19,7 @@ export async function signRelease(
   const [ipfs, ...ipfsExtras] = ipfsArr;
 
   // Format release hash, remove prefix
-  const releaseCID = CID.parse(parseIpfsPath(releaseHash));
+  const releaseCID = CID.parse(normalizeIpfsPath(releaseHash));
 
   const releaseRootDag: IpfsDagGetResult<IpfsDagPbValue> = await ipfs.dag.get(
     releaseCID
@@ -209,7 +209,7 @@ function dagGetToFiles(
   content: IpfsDagGetResult<IpfsDagPbValue>
 ): { name: string; cid: CID }[] {
   return content.value.Links.map((link) => ({
-    cid: CID.parse(parseIpfsPath(link.Hash.toString())),
+    cid: CID.parse(normalizeIpfsPath(link.Hash.toString())),
     name: link.Name,
   }));
 }