实战｜DeLinkedIn 全栈开发：Web3 身份验证 + 数字资产确权，搭建职场社交新生态

木西
发布于 1小时前
阅读 24

前言本文主要整合往期发布的DAO、SSI身份、社区所有权社交等相关内容，实现一个简洁的去中心化社区实例。延续以往风格理论加代码实践相结合。概述在2026年，职场社交正在经历从“平台信用”向“加密证明”的范式转移。传统的LinkedIn依赖于用户自述的简历，而DeLinke

# 前言
> 本文主要整合往期发布的 **DAO、SSI 身份、社区所有权社交** 等相关内容，实现一个简洁的**去中心化社区**实例。延续以往风格 理论加代码实践相结合。
# 概述
在 2026 年，职场社交正在经历从“平台信用”向“加密证明”的范式转移。传统的 LinkedIn 依赖于用户自述的简历，而 **DeLinkedIn** 则是通过 **SSI (自主主权身份)** 、**Social NFT (内容所有权)**  和 **DAO (去中心化治理)**  的三位一体架构，构建了一个真实、透明且价值对等的职业生态。
#  核心架构理论：三权分立

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

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

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

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

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

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

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

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

**三步闭环**
| 步骤        | 角色     | 链上动作                    | 传统痛点      | 合约解决方案        |
| --------- | ------ | ----------------------- | --------- | ------------- |
| **1. 锁仓** | 企业     | `postJobBounty()` 锁定赏金  | 口头承诺无保障   | 资金托管在合约，无法撤回  |
| **2. 推荐** | 专业人士   | `referCandidate()` 记录关系 | 推荐关系难证明   | DID身份绑定，链上可追溯 |
| **3. 结算** | 企业/DAO | `fulfillBounty()` 自动拨付  | 结算周期长、扯皮多 | 条件触发，秒级到账     |

***
# 智能合约落地全流程
### 智能合约
* **去中心化领英**
```
// 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）已全部完成。本文延续了“理论+代码”的呈现风格，从项目架构设计、核心业务逻辑拆解，到智能合约开发、测试脚本编写、部署脚本实现，完整呈现了去中心化社区的落地过程。

前言

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

概述

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

核心架构理论：三权分立

身份层 (SSI/SBT)：真实性的根基
- 理论：简历不再是 PDF，而是由大学、前雇主或开源组织签发的灵魂绑定代币 (SBT) 。
- 解决痛点：消除简历造假。只有持有特定技能凭证的用户才能进入高阶人才库。
社交层 (Community Ownership)：内容即资产
- 理论：每一次职场深度分享都铸造为 ERC-721 NFT。
- 解决痛点：创作者拥有粉丝关系和内容的所有权，平台无法通过流量抽成剥削职场博主。
治理层 (DAO/Token)：共建者激励
- 理论：平台由持有 Governance Token 的成员共有。优质内容的产出直接由 DAO 金库进行代币奖励。
- 解决痛点：将“用户流量”转化为“社区股份”，实现利益共担。

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

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

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

三步闭环	步骤	角色	链上动作	传统痛点
1. 锁仓	企业	`postJobBounty()` 锁定赏金	口头承诺无保障	资金托管在合约，无法撤回
2. 推荐	专业人士	`referCandidate()` 记录关系	推荐关系难证明	DID身份绑定，链上可追溯
3. 结算	企业/DAO	`fulfillBounty()` 自动拨付	结算周期长、扯皮多	条件触发，秒级到账

智能合约落地全流程

智能合约

去中心化领英


// 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();


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

原创
学分: 0
分类: 以太坊
标签: 智能合约 Solidity #SSI #社区所有权

本文参与登链社区写作激励计划，好文好收益，欢迎正在阅读的你也加入。

实战｜DeLinkedIn 全栈开发：Web3 身份验证 + 数字资产确权，搭建职场社交新生态

前言

概述

核心架构理论：三权分立

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

智能合约落地全流程

智能合约

0 条评论

文章目录