@dpa-oss/dpa 1.0.0

package/contracts/examples/AssetDPA.sol

@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "../DPA.sol";
+
+/**
+ * @title AssetDPA
+ * @dev Example implementation of the abstract DPA contract
+ *      Demonstrates how to define a custom struct and decode content
+ */
+contract AssetDPA is DPA {
+    /// @notice Asset type enumeration
+    enum AssetType {
+        Enum1,
+        Enum2
+    }
+
+    /// @notice Asset content structure
+    struct AssetContent {
+        uint256 amount;
+        AssetType assetType;
+    }
+
+    // ============ Events ============
+
+    /// @notice Emitted when asset content is decoded (for indexing)
+    event AssetContentStored(
+        uint256 indexed tokenId,
+        uint256 amount,
+        AssetType assetType
+    );
+
+    // ============ Constructor ============
+
+    /**
+     * @param orchestrator_ Initial orchestrator address
+     */
+    constructor(
+        address orchestrator_
+    ) DPA("Asset DPA", "ASSET-DPA", orchestrator_) {}
+
+    // ============ View Functions ============
+
+    /**
+     * @notice Decodes and returns the asset content for a token
+     * @param tokenId Token to query
+     * @return content The decoded AssetContent struct
+     */
+    function getAssetContent(
+        uint256 tokenId
+    ) external view returns (AssetContent memory content) {
+        bytes memory rawContent = this.tokenContent(tokenId);
+        content = abi.decode(rawContent, (AssetContent));
+    }
+
+    // ============ Internal Functions ============
+
+    /**
+     * @dev Validates that content can be decoded as AssetContent
+     * @param content The encoded content to validate
+     */
+    function _validateContent(bytes calldata content) internal pure override {
+        // Attempt to decode - will revert if invalid
+        abi.decode(content, (AssetContent));
+    }
+
+    // ============ Helper Functions ============
+
+    /**
+     * @notice Helper to encode AssetContent for minting
+     * @param amount The amount value
+     * @param assetType The asset type
+     * @return Encoded bytes
+     */
+    function encodeAssetContent(
+        uint256 amount,
+        AssetType assetType
+    ) external pure returns (bytes memory) {
+        return abi.encode(AssetContent({amount: amount, assetType: assetType}));
+    }
+}

package/contracts/shared/Errors.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+/**
+ * @title Errors
+ * @dev Unified error codes for DPA ecosystem
+ */
+library Errors {
+    /// @dev Caller is not the orchestrator
+    error NotOrchestrator();
+
+    /// @dev Token does not exist
+    error InvalidTokenId();
+
+    /// @dev Revision chain violation
+    error InvalidRevision();
+
+    /// @dev Batch minting error
+    error BatchMintFailed();
+
+    /// @dev Arrays length mismatch
+    error ArrayLengthMismatch();
+
+    /// @dev Zero address provided
+    error ZeroAddress();
+
+    /// @dev Attempted to revise a token that is not the latest version
+    error NotLatestVersion();
+
+    /// @dev Link name already exists for this token
+    error DuplicateLinkName();
+
+    /// @dev Link name not found for this token
+    error LinkNotFound();
+
+    /// @dev Link name cannot be empty
+    error EmptyLinkName();
+
+    /// @dev Address is not a contract
+    error NotAContract();
+
+    /// @dev Cannot link to self
+    error SelfLink();
+
+    /// @dev Token burning is disabled
+    error BurnDisabled();
+
+    /// @dev Linked contract does not implement IDPA interface
+    error NotADPAContract();
+}

package/contracts/shared/IDPA.sol

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "./Types.sol";
+import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+/**
+ * @title IDPA
+ * @dev Interface for Digital Public Asset contracts
+ *      Defines the standard functions for DPA implementations
+ *      Extends IERC165 for interface detection
+ */
+interface IDPA is IERC165 {
+    // ============ Admin Functions ============
+
+    /// @notice Returns the current orchestrator address
+    function orchestrator() external view returns (address);
+
+    /// @notice Updates the orchestrator address (owner only)
+    function setOrchestrator(address newOrchestrator) external;
+
+    /// @notice Pauses all minting and revision operations (owner only)
+    function pause() external;
+
+    /// @notice Unpauses all minting and revision operations (owner only)
+    function unpause() external;
+
+    // ============ Minting Functions ============
+
+    /// @notice Mints a single token with URI and content
+    function mint(
+        address to,
+        string calldata uri,
+        bytes calldata content
+    ) external returns (uint256 tokenId);
+
+    /// @notice Mints a single token with explicit owner specification
+    function mintWithOwner(
+        address to,
+        address owner_,
+        string calldata uri,
+        bytes calldata content
+    ) external returns (uint256 tokenId);
+
+    /// @notice Batch mints tokens with URIs and contents
+    function batchMint(
+        address to,
+        string[] calldata uris,
+        bytes[] calldata contents
+    ) external returns (uint256 startTokenId);
+
+    // ============ Revision Functions ============
+
+    /// @notice Creates a new revision of an existing token (protocol-enforced)
+    /// @param parentTokenId The token being revised (must be latest version)
+    /// @param uri New token URI
+    /// @param content New encoded content
+    /// @param reason Human-readable reason for revision
+    /// @return newTokenId The newly minted revision token
+    function revise(
+        uint256 parentTokenId,
+        string calldata uri,
+        bytes calldata content,
+        string calldata reason
+    ) external returns (uint256 newTokenId);
+
+    // ============ Query Functions ============
+
+    /// @notice Returns the token URI
+    function tokenURI(uint256 tokenId) external view returns (string memory);
+
+    /// @notice Returns the raw encoded content for a token
+    function tokenContent(uint256 tokenId) external view returns (bytes memory);
+
+    /// @notice Returns the revision record for a token
+    function getRevisionRecord(
+        uint256 tokenId
+    ) external view returns (Types.RevisionRecord memory);
+
+    /// @notice Returns the full revision chain from origin to the given token
+    function getRevisionChain(
+        uint256 tokenId
+    ) external view returns (uint256[] memory chain);
+
+    /// @notice Returns the latest version in a revision chain
+    function getLatestVersion(
+        uint256 originTokenId
+    ) external view returns (uint256 latestTokenId);
+
+    /// @notice Returns the child token of a given token (0 if none)
+    function getChildToken(
+        uint256 tokenId
+    ) external view returns (uint256 childTokenId);
+
+    /// @notice Returns the total count of unique digital public assets
+    function getTotalAssets() external view returns (uint256 total);
+
+    /// @notice Checks if a token is the latest version in its chain
+    function isLatestVersion(
+        uint256 tokenId
+    ) external view returns (bool isLatest);
+
+    /// @notice Returns the origin token ID for any token in a revision chain
+    function getOriginToken(
+        uint256 tokenId
+    ) external view returns (uint256 originTokenId);
+
+    /// @notice Returns the version number of a token
+    function getVersion(
+        uint256 tokenId
+    ) external view returns (uint256 version);
+}

package/contracts/shared/Types.sol

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+/**
+ * @title Types
+ * @dev Shared types for DPA ecosystem
+ */
+library Types {
+    /// @dev Record of a revision in the linked list
+    struct RevisionRecord {
+        uint256 previousTokenId; // Parent revision (0 if origin)
+        uint256 originTokenId; // Root of the revision chain
+        uint256 version; // Version number (1 for origin, increments on each revision)
+        bytes32 reasonHash; // Keccak256 hash of reason (full reason in event)
+        uint256 timestamp; // When created
+        address actor; // Who created this
+    }
+}

package/hardhat.config.ts

@@ -0,0 +1,23 @@
+import { HardhatUserConfig } from "hardhat/config";
+import "@nomicfoundation/hardhat-toolbox";
+import "hardhat-gas-reporter";
+
+const config: HardhatUserConfig = {
+  solidity: {
+    version: "0.8.20",
+    settings: {
+      optimizer: {
+        enabled: true,
+        runs: 200,
+      },
+    },
+  },
+  gasReporter: {
+    enabled: true,
+    currency: "USD",
+    outputFile: "gas-report.txt",
+    noColors: true,
+  },
+};
+
+export default config;

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@dpa-oss/dpa",
+  "version": "1.0.0",
+  "scripts": {
+    "compile": "hardhat compile",
+    "test": "hardhat test",
+    "clean": "hardhat clean"
+  },
+  "keywords": [],
+  "author": "Jason Cruz",
+  "license": "ISC",
+  "description": "DPA (Digital Public Asset) Smart Contracts",
+  "devDependencies": {
+    "@nomicfoundation/hardhat-toolbox": "^4.0.0",
+    "@types/node": "^20.0.0",
+    "hardhat": "^2.22.0",
+    "hardhat-gas-reporter": "^2.3.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@openzeppelin/contracts": "^5.0.0",
+    "erc721a": "^4.3.0"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "outDir": "./dist"
+  },
+  "include": ["./scripts", "./test", "./hardhat.config.ts"],
+  "files": ["./hardhat.config.ts"]
+}