前言

本文主要整合往期发布的 DAO、SSI 身份、社区所有权社交 等相关内容，实现一个简洁的去中心化社区实例。延续以往风格 理论加代码实践相结合。

概述

在 2026 年，职场社交正在经历从“平台信用”向“加密证明”的范式转移。传统的 LinkedIn 依赖于用户自述的简历，而 DeLinkedIn 则是通过 SSI (自主主权身份) 、Social NFT (内容所有权)  和 DAO (去中心化治理)  的三位一体架构，构建了一个真实、透明且价值对等的职业生态。

核心架构理论：三权分立

1. 身份层 (SSI/SBT)：真实性的根基

   • 理论：简历不再是 PDF，而是由大学、前雇主或开源组织签发的灵魂绑定代币 (SBT) 。
   • 解决痛点：消除简历造假。只有持有特定技能凭证的用户才能进入高阶人才库。

2. 社交层 (Community Ownership)：内容即资产

   • 理论：每一次职场深度分享都铸造为 ERC-721 NFT。
   • 解决痛点：创作者拥有粉丝关系和内容的所有权，平台无法通过流量抽成剥削职场博主。

3. 治理层 (DAO/Token)：共建者激励

   • 理论：平台由持有 Governance Token 的成员共有。优质内容的产出直接由 DAO 金库进行代币奖励。
   • 解决痛点：将“用户流量”转化为“社区股份”，实现利益共担。

猎头赏金：智能合约如何重构招聘经济学

1. 企业发布（Post & Lock）：企业发布职位并锁定一定数额的平台代币（赏金）到合约。
2. 用户推荐（Referral）：用户通过自己的 DID 身份推荐好友。
3. 多签结算（Settlement）：当好友入职通过试用期，企业或 DAO 触发结算，赏金自动拨付给推荐人。

DeLinkedIn的BountyLinkedIn合约将传统猎头的"人治"流程改造为无需信任的自动化协议

智能合约落地全流程

智能合约

• 去中心化领英

  
  // SPDX-License-Identifier: MIT
  pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/access/AccessControl.sol";

// 身份接口：用于核验用户是否拥有“技能凭证” interface ISoulboundIdentity { function balanceOf(address owner) external view returns (uint256); }

contract DeLinkedIn is ERC721, AccessControl { bytes32 public constant MODERATOR_ROLE = keccak256("MODERATOR_ROLE"); IERC20 public platformToken; ISoulboundIdentity public sbtIdentity;

uint256 private _nextPostId;
uint256 public constant POST_REWARD = 10 * 10**18; // 发帖奖励 10 Token

struct WorkPost {
    address author;
    string metadataUri; // 职业动态内容
    bool isVerifiedPro; // 是否为核验专家
}

mapping(uint256 => WorkPost) public posts;

error NotSkillCertified(); // 未获得技能认证（SSI 拦截）
error rewardTransferFailed();

constructor(address _token, address _sbt) ERC721("DeLinkedInPost", "DLP") {
    _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
    platformToken = IERC20(_token);
    sbtIdentity = ISoulboundIdentity(_sbt);
}
function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, AccessControl)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
/**
 * @dev 发布职场动态：只有持有 SSI 技能凭证的用户才能发布
 */
function publishProfessionalInsight(string memory _uri) external {
    // 1. SSI 身份核验：检查用户是否持有灵魂绑定技能凭证
    if (sbtIdentity.balanceOf(msg.sender) == 0) {
        revert NotSkillCertified();
    }

    // 2. 社区所有权：内容 NFT 化
    uint256 tokenId = _nextPostId++;
    _safeMint(msg.sender, tokenId);
    posts[tokenId] = WorkPost(msg.sender, _uri, true);

    // 3. 经济激励：给创作者发放平台代币奖励（由 DAO 金库支持）
    bool success = platformToken.transfer(msg.sender, POST_REWARD);
    if (!success) revert rewardTransferFailed();
}

}

* **猎头赏金**:

// SPDX-License-Identifier: MIT pragma solidity ^0.8.24;

import "./DeLinkedIn.sol"; // 继承之前的逻辑

contract BountyLinkedIn is DeLinkedIn { struct JobBounty { address employer; uint256 rewardAmount; bool isActive; }

// 职位 ID => 赏金信息
mapping(uint256 => JobBounty) public jobBounties;
// 推荐记录：候选人地址 => 推荐人地址
mapping(address => address) public referrals;

event BountyPosted(uint256 jobId, uint256 amount);
event BountyClaimed(uint256 jobId, address indexed referrer, address indexed candidate);

constructor(address _token, address _sbt) DeLinkedIn(_token, _sbt) {}

/**
 * @dev 企业发布赏金职位
 */
function postJobBounty(uint256 _jobId, uint256 _amount) external {
    platformToken.transferFrom(msg.sender, address(this), _amount);
    jobBounties[_jobId] = JobBounty(msg.sender, _amount, true);
    emit BountyPosted(_jobId, _amount);
}

/**
 * @dev 用户提交推荐：记录推荐关系
 */
function referCandidate(address _candidate) external {
    if (sbtIdentity.balanceOf(msg.sender) == 0) revert NotSkillCertified();
    referrals[_candidate] = msg.sender;
}

/**
 * @dev 企业确认入职，拨付赏金给推荐人
 */
function fulfillBounty(uint256 _jobId, address _candidate) external {
    JobBounty storage bounty = jobBounties[_jobId];
    require(msg.sender == bounty.employer, "Only employer can fulfill");
    require(bounty.isActive, "Bounty not active");

    address referrer = referrals[_candidate];
    require(referrer != address(0), "No referrer found");

    bounty.isActive = false;
    platformToken.transfer(referrer, bounty.rewardAmount);

    emit BountyClaimed(_jobId, referrer, _candidate);
}

}

### 测试脚本
**测试用例**：DeLinkedIn 综合项目测试 (SSI + Social + DAO)
* **核验通过的专业人士应能发布动态并获得代币奖励** 
* **未获得 SSI 认证的‘游客’尝试发布应被拒绝** 

import assert from "node:assert/strict"; import { describe, it, beforeEach } from "node:test"; import { network } from "hardhat"; import { parseEther } from 'viem';

describe("DeLinkedIn 综合项目测试 (SSI + Social + DAO)", function () { let delinkedIn: any, token: any, sbt: any; let publicClient, testClient; let admin: any, user: any, stranger: any;

beforeEach(async function () {
    const { viem: v } = await (network as any).connect();
    publicClient = await v.getPublicClient();
    testClient = await v.getTestClient();
    [admin, user, stranger] = await v.getWalletClients();

    // 1. 部署基础设施
    token = await v.deployContract("contracts/DAO.sol:MyToken", []); 
    sbt = await v.deployContract("contracts/SoulboundIdentity.sol:SoulboundIdentity", []);

    // 2. 部署领英主合约
    delinkedIn = await v.deployContract("contracts/DeLinkedIn.sol:DeLinkedIn", [
        token.address, 
        sbt.address
    ]);

    // 3. 注入 DAO 奖励金库资金
    await token.write.transfer([delinkedIn.address, parseEther("1000")]);

    // 4. 为 SSI 合约设置签发者并给 user 签发一个技能凭证
    const ISSUER_ROLE = await sbt.read.ISSUER_ROLE();
    await sbt.write.grantRole([ISSUER_ROLE, admin.account.address]);
    await sbt.write.issueIdentity([user.account.address, "ipfs://Senior-Dev-Cert", 0n]);
});

it("核验通过的专业人士应能发布动态并获得代币奖励", async function () {
    const initialBalance = await token.read.balanceOf([user.account.address]);

    // 用户发布动态
    await delinkedIn.write.publishProfessionalInsight(["ipfs://My-Web3-Insight"], { account: user.account });

    // 验证 1: 内容所有权 (NFT)
    const nftBalance = await delinkedIn.read.balanceOf([user.account.address]);
    assert.equal(nftBalance, 1n, "应获得内容所有权 NFT");

    // 验证 2: 经济激励 (Token)
    const finalBalance = await token.read.balanceOf([user.account.address]);
    assert.equal(finalBalance - initialBalance, parseEther("10"), "应获得 10 枚代币奖励");
});

it("未获得 SSI 认证的‘游客’尝试发布应被拒绝", async function () {
    await assert.rejects(
        delinkedIn.write.publishProfessionalInsight(["ipfs://Fake-Insight"], { account: stranger.account }),
        /NotSkillCertified/,
        "未认证用户必须被 SSI 逻辑拦截"
    );
});

});

**测试用例**：猎头赏金流程测试
* **发布赏金 -> 推荐好友 -> 入职结算的闭环**

import assert from "node:assert/strict"; import { describe, it, beforeEach } from "node:test"; import { network} from "hardhat"; import { parseEther } from 'viem';

describe("DeLinkedIn 猎头赏金流程测试", function () { let bountyContract: any, token: any, sbt: any; let publicClient; let employer: any, referrer: any, candidate: any;

beforeEach(async function () {
    const { viem: v } = await (network as any).connect();
    publicClient = await v.getPublicClient();
    [employer, referrer, candidate] = await v.getWalletClients();

    // 部署
    token = await v.deployContract("contracts/DAO.sol:MyToken", []);
    sbt = await v.deployContract("contracts/SoulboundIdentity.sol:SoulboundIdentity", []);
    bountyContract = await v.deployContract("contracts/BountyLinkedIn.sol:BountyLinkedIn", [token.address, sbt.address]);

    // 初始化：给推荐人签发技能身份，给企业发钱
    const ISSUER_ROLE = await sbt.read.ISSUER_ROLE();
    await sbt.write.grantRole([ISSUER_ROLE, employer.account.address]);
    await sbt.write.issueIdentity([referrer.account.address, "ipfs://Expert", 0n]);
    await token.write.transfer([employer.account.address, parseEther("500")]);
});

it("应该完成：发布赏金 -> 推荐好友 -> 入职结算的闭环", async function () {
    const bountyAmount = parseEther("100");

    // 1. 企业发布赏金
    await token.write.approve([bountyContract.address, bountyAmount], { account: employer.account });
    await bountyContract.write.postJobBounty([1n, bountyAmount], { account: employer.account });

    // 2. 推荐人推荐候选人
    await bountyContract.write.referCandidate([candidate.account.address], { account: referrer.account });

    // 3. 企业确认入职并拨付
    const initialBalance = await token.read.balanceOf([referrer.account.address]);
    await bountyContract.write.fulfillBounty([1n, candidate.account.address], { account: employer.account });

    // 4. 验证推荐人收到赏金
    const finalBalance = await token.read.balanceOf([referrer.account.address]);
    assert.equal(finalBalance - initialBalance, bountyAmount, "推荐人应收到 100 枚代币赏金");
});

});

### 部署脚本

// scripts/deploy.js import { network, artifacts } from "hardhat"; async function main() { // 连接网络 const { viem } = await network.connect({ network: network.name });//指定网络进行链接

// 获取客户端 const [deployer] = await viem.getWalletClients(); const publicClient = await viem.getPublicClient();

const deployerAddress = deployer.account.address; console.log("部署者的地址:", deployerAddress); // 加载合约 const TokenArtifact = await artifacts.readArtifact("contracts/DAO.sol:MyToken"); const SoulboundIdentityArtifact = await artifacts.readArtifact("contracts/SoulboundIdentity.sol:SoulboundIdentity"); const DeLinkedInArtifact = await artifacts.readArtifact("contracts/DeLinkedIn.sol:DeLinkedIn"); const BountyLinkedInArtifact = await artifacts.readArtifact("contracts/BountyLinkedIn.sol:BountyLinkedIn"); const TokenHash = await deployer.deployContract({ abi: TokenArtifact.abi,//获取abi bytecode: TokenArtifact.bytecode,//硬编码 args: [], }); const TokenReceipt = await publicClient.waitForTransactionReceipt({ hash: TokenHash }); console.log("Token合约地址:", TokenReceipt.contractAddress); // 部署 const SoulboundIdentityHash = await deployer.deployContract({ abi: SoulboundIdentityArtifact.abi,//获取abi bytecode: SoulboundIdentityArtifact.bytecode,//硬编码 args: [], }); const SoulboundIdentityReceipt = await publicClient.waitForTransactionReceipt({ hash: SoulboundIdentityHash }); console.log("SoulboundIdentity合约地址:", SoulboundIdentityReceipt.contractAddress); const DeLinkedInHash = await deployer.deployContract({ abi: DeLinkedInArtifact.abi,//获取abi bytecode: DeLinkedInArtifact.bytecode,//硬编码 args: [TokenReceipt.contractAddress, SoulboundIdentityReceipt.contractAddress], }); const DeLinkedInReceipt = await publicClient.waitForTransactionReceipt({ hash: DeLinkedInHash }); console.log("DeLinkedIn合约地址:", DeLinkedInReceipt.contractAddress); const BountyLinkedInHash = await deployer.deployContract({ abi: BountyLinkedInArtifact.abi,//获取abi bytecode: BountyLinkedInArtifact.bytecode,//硬编码 args: [TokenReceipt.contractAddress, SoulboundIdentityReceipt.contractAddress], }); const BountyLinkedInReceipt = await publicClient.waitForTransactionReceipt({ hash: BountyLinkedInHash }); console.log("BountyLinkedIn合约地址:", BountyLinkedInReceipt.contractAddress); } main().catch(console.error);

# 结语
至此，基于**DAO、SSI身份、社区所有权社交**三大核心技术的综合案例——2026去中心化领英（DeLinkedIn）已全部完成。本文延续了“理论+代码”的呈现风格，从项目架构设计、核心业务逻辑拆解，到智能合约开发、测试脚本编写、部署脚本实现，完整呈现了去中心化社区的落地过程。