SecurityTokenTokenizerV7

// Company issues $5M in Reg D securities
// Only accredited investors can receive/transfer
 
// Reserve for accredited investor
securityTokenizer.reserveToken(
    offeringHash,
    0,
    investorAddress,  // Must be accredited
    50000 * 1e18,    // $50k investment
    processHash
);
 
// Investor claims (requires accreditation attestation)
securityTokenizer.claimToken(
    offeringHash,
    0,
    accreditationAttestationUID,  // Proves accredited status
    processHash
);
 
// Transfer restrictions enforced via attestations
// Can only transfer to other accredited investors

// $10M municipal bond offering
bytes32 bondHash = keccak256("municipal_bond_2024");
 
// Reserve for institutional investors
securityTokenizer.reserveToken(bondHash, 0, bank1, 5000000 * 1e18, processHash);
securityTokenizer.reserveToken(bondHash, 0, bank2, 3000000 * 1e18, processHash);
securityTokenizer.reserveToken(bondHash, 0, fundManager, 2000000 * 1e18, processHash);
 
// Each must prove qualified purchaser status to claim

// Token sale with compliance requirements
// Investors must pass KYC/AML
 
securityTokenizer.reserveToken(
    stoHash,
    0,
    investorAddress,
    10000 * 1e18,
    processHash
);
 
// Claim requires:
// 1. KYC/AML attestation
// 2. Accreditation attestation (if applicable)
// 3. Jurisdiction attestation (geographic restrictions)

// Shares can only be transferred with board approval
 
// Initial issuance
securityTokenizer.reserveToken(sharesHash, 0, founder, 1000000, processHash);
 
// Founder wants to sell
// Requires board approval attestation for transfer
// Without attestation → transfer fails

// Standard ERC-20 transfer
function transfer(address to, uint256 amount) public override returns (bool) {
    // Requires recipient to have valid compliance attestation
    // Checked via capability system
    require(hasTransferCapability(to), "Recipient not compliant");
    return super.transfer(to, amount);
}

// Claim requires accreditation attestation
requiresCapabilityWithUID(integraHash, CAPABILITY_CLAIM_TOKEN, capabilityAttestationUID)
 
// Attestation proves:
// - Net worth > $1M (excluding primary residence)
// OR
// - Income > $200k ($300k joint) for 2+ years

function reserveTokenAnonymous(...) external {
    revert("Use reserveToken for security tokens");
}

struct ShareData {
    // ...
    address[] shareholders;  // All token holders
}
 
// Enables:
// - Regulatory reporting
// - Cap table management
// - Compliance audits

// When all shares distributed:
// - Trust credentials issued to shareholders
// - Builds on-chain compliance history

struct ShareData {
    bytes32 integraHash;
    uint256 totalShares;       // Total distributed shares
    uint256 reservedShares;    // Not yet claimed
    mapping(address => uint256) reservations;
    mapping(address => bool) claimed;
    address[] shareholders;    // Shareholder registry
}
 
mapping(bytes32 => ShareData) private shareData;
IEAS private eas;  // Attestation service

ERC20Upgradeable (OpenZeppelin)
├─ Fungible token standard
└─ Transfer, approve, allowance

BaseTokenizerV7
├─ Access control
├─ Capability verification (compliance enforcement)
├─ Document registry integration
└─ Process hash validation

TrustGraphIntegration
├─ Trust credential issuance
├─ Compliance reputation
└─ EAS integration

function initialize(
    string memory name_,        // e.g., "Acme Corp Preferred Stock"
    string memory symbol_,      // e.g., "ACME-PS"
    address governor,
    address _documentRegistry,
    address _namespace,
    address _providerRegistry,
    bytes32 _defaultProviderId,
    bytes32 _credentialSchema,
    address _trustRegistry,
    address _easAddress
) external initializer

function reserveToken(
    bytes32 integraHash,
    uint256 tokenId,     // Ignored (ERC-20)
    address recipient,   // Must be compliant investor
    uint256 amount,      // Number of security tokens
    bytes32 processHash
) external override requireOwnerOrExecutor(integraHash) nonReentrant whenNotPaused

// Reserve 10,000 security tokens for accredited investor
securityTokenizer.reserveToken(
    offeringHash,
    0,
    accreditedInvestor,
    10000 * 1e18,
    processHash
);

function reserveTokenAnonymous(...) external {
    revert("Use reserveToken for security tokens");
}

function claimToken(
    bytes32 integraHash,
    uint256 tokenId,
    bytes32 capabilityAttestationUID,  // Proves accreditation/compliance
    bytes32 processHash
) external override requiresCapabilityWithUID(...) nonReentrant whenNotPaused

// Investor claims securities
securityTokenizer.claimToken(
    offeringHash,
    0,
    accreditationAttestationUID,  // From registered attestation provider
    processHash
);
// Investor receives 10,000 security tokens

function cancelReservation(...) external {
    revert("Use specific cancellation function");
}

function balanceOf(address account, uint256) public view returns (uint256)

function getTokenInfo(bytes32 integraHash, uint256)
    external view returns (IDocumentTokenizerV7.TokenInfo memory)

// 1. DEPLOY
SecurityTokenTokenizerV7 securityToken = new SecurityTokenTokenizerV7();
securityToken.initialize(
    "Acme Corp Series A Preferred",
    "ACME-SRA",
    governor,
    documentRegistry,
    namespace,
    providerRegistry,
    defaultProviderId,
    credentialSchema,
    trustRegistry,
    easAddress
);
 
// 2. RESERVE SECURITIES FOR ACCREDITED INVESTORS
 
// Investor 1: $500k
securityToken.reserveToken(
    offeringHash,
    0,
    investor1,
    500000 * 1e18,
    processHash
);
 
// Investor 2: $300k
securityToken.reserveToken(
    offeringHash,
    0,
    investor2,
    300000 * 1e18,
    processHash
);
 
// Investor 3: $200k
securityToken.reserveToken(
    offeringHash,
    0,
    investor3,
    200000 * 1e18,
    processHash
);
 
// 3. INVESTORS CLAIM WITH COMPLIANCE ATTESTATIONS
 
// Investor 1 proves accreditation
securityToken.claimToken(
    offeringHash,
    0,
    investor1AccreditationUID,  // EAS attestation from compliance provider
    processHash
);
// Investor 1 receives 500,000 security tokens
 
// Investor 2 proves accreditation
securityToken.claimToken(
    offeringHash,
    0,
    investor2AccreditationUID,
    processHash
);
 
// Investor 3 proves accreditation
securityToken.claimToken(
    offeringHash,
    0,
    investor3AccreditationUID,
    processHash
);
 
// 4. ALL SECURITIES DISTRIBUTED
// → Trust credentials issued to all shareholders
// → Shareholder registry complete
 
// 5. SECONDARY TRANSFERS (with restrictions)
 
// Investor 1 wants to sell to Investor 4
// Requires:
// 1. Investor 4 has compliance attestation
// 2. Board approval (if required)
// 3. No lock-up period violations
 
// Standard ERC-20 transfer (if compliant)
securityToken.transfer(investor4, 100000 * 1e18);

REGISTRATION → VERIFICATION → ACCREDITATION → RESERVATION → CLAIM → HOLDING → TRANSFER (if compliant)

// Verify attestation provider is registered
require(providerRegistry.isAuthorized(attestationProvider), "Unauthorized provider");

function _beforeTokenTransfer(address from, address to, uint256 amount)
    internal override
{
    if (from != address(0) && to != address(0)) {
        // Verify recipient has compliance capability
        require(hasCompliance(to), "Recipient not compliant");
    }
    super._beforeTokenTransfer(from, to, amount);
}

// All shareholders recorded
address[] shareholders = shareData[offeringHash].shareholders;
 
// Enables:
// - Regulatory reporting
// - Compliance audits
// - Cap table management

mapping(address => uint256) public lockupExpiry;
 
function _beforeTokenTransfer(address from, address to, uint256 amount)
    internal override
{
    if (from != address(0)) {
        require(block.timestamp >= lockupExpiry[from], "Lock-up period active");
    }
    super._beforeTokenTransfer(from, to, amount);
}

// Log all transfers
event SecurityTransfer(
    address indexed from,
    address indexed to,
    uint256 amount,
    bytes32 complianceAttestationUID,
    uint256 timestamp
);

// Private placement under Regulation D
function conductRegDOffering(
    bytes32 offeringHash,
    address[] memory accreditedInvestors,
    uint256[] memory amounts
) external onlyRole(ISSUER_ROLE) {
    require(accreditedInvestors.length == amounts.length, "Length mismatch");
 
    for (uint i = 0; i < accreditedInvestors.length; i++) {
        securityToken.reserveToken(
            offeringHash,
            0,
            accreditedInvestors[i],
            amounts[i],
            processHash
        );
    }
}

// Verify investor compliance before transfer
function verifyCompliance(address investor) public view returns (bool) {
    // Check if investor has valid compliance attestations
    bytes32[] memory attestations = easRegistry.getAttestations(investor);
 
    for (uint i = 0; i < attestations.length; i++) {
        Attestation memory att = eas.getAttestation(attestations[i]);
 
        // Check for accreditation attestation
        if (att.schema == ACCREDITATION_SCHEMA && att.expirationTime > block.timestamp) {
            return true;
        }
    }
 
    return false;
}

// Export shareholder registry for compliance reporting
function exportCapTable(bytes32 offeringHash)
    external view returns (address[] memory, uint256[] memory)
{
    ShareData storage data = shareData[offeringHash];
    address[] memory shareholders = data.shareholders;
    uint256[] memory balances = new uint256[](shareholders.length);
 
    for (uint i = 0; i < shareholders.length; i++) {
        balances[i] = balanceOf(shareholders[i], 0);
    }
 
    return (shareholders, balances);
}

// Register as compliance provider
async function registerAsComplianceProvider() {
  const providerRegistry = await ethers.getContractAt(
    "AttestationProviderRegistryV7",
    providerRegistryAddress
  );
 
  await providerRegistry.registerProvider(
    providerId,
    providerMetadata
  );
}
 
// Issue accreditation attestation
async function issueAccreditationAttestation(investor: string) {
  // Verify investor is accredited (off-chain checks)
  const isAccredited = await verifyAccreditation(investor);
 
  if (!isAccredited) {
    throw new Error("Investor not accredited");
  }
 
  // Issue EAS attestation
  const attestation = await eas.attest({
    schema: ACCREDITATION_SCHEMA,
    data: {
      recipient: investor,
      expirationTime: oneYearFromNow,
      revocable: true,
      data: encodeAccreditationData(investor)
    }
  });
 
  return attestation.wait();
}

// Investor onboarding flow
class SecurityTokenOnboarding {
  async onboardInvestor(investorData) {
    // 1. KYC/AML verification
    const kycResult = await this.performKYC(investorData);
    if (!kycResult.passed) {
      throw new Error("KYC failed");
    }
 
    // 2. Accreditation verification
    const accreditationResult = await this.verifyAccreditation(investorData);
    if (!accreditationResult.isAccredited) {
      throw new Error("Not accredited");
    }
 
    // 3. Issue compliance attestation
    const attestationUID = await this.issueComplianceAttestation(
      investorData.address
    );
 
    // 4. Register investor
    await db.investors.create({
      address: investorData.address,
      kycStatus: "approved",
      accreditationStatus: "verified",
      attestationUID,
      onboardedAt: new Date()
    });
 
    return attestationUID;
  }
}

// Store all compliance-related data
struct ComplianceRecord {
    bytes32 attestationUID;
    uint256 verificationDate;
    uint256 expirationDate;
    string verificationType;
    address verifier;
}
 
mapping(address => ComplianceRecord[]) public complianceHistory;

// Periodic compliance checks
async function auditCompliance() {
  const shareholders = await securityToken.getShareholderRegistry(offeringHash);
 
  for (const shareholder of shareholders) {
    const isCompliant = await verifyCurrentCompliance(shareholder);
 
    if (!isCompliant) {
      // Alert compliance team
      await notifyComplianceTeam(shareholder, "Compliance lapsed");
    }
  }
}

// Implement transfer approval for restricted securities
mapping(bytes32 => bool) public transferApproved;
 
function approveTransfer(
    address from,
    address to,
    uint256 amount,
    bytes32 approvalHash
) external onlyRole(COMPLIANCE_ROLE) {
    transferApproved[approvalHash] = true;
    emit TransferApproved(from, to, amount, approvalHash);
}
 
function _beforeTokenTransfer(address from, address to, uint256 amount)
    internal override
{
    if (from != address(0) && to != address(0)) {
        bytes32 transferHash = keccak256(abi.encodePacked(from, to, amount));
        require(transferApproved[transferHash], "Transfer not approved");
        delete transferApproved[transferHash];  // One-time use
    }
    super._beforeTokenTransfer(from, to, amount);
}

// Generate regulatory reports
async function generateForm D() {
  const offering = await securityToken.getTokenInfo(offeringHash, 0);
 
  return {
    issuer: companyInfo,
    offeringAmount: totalOffering,
    investorCount: offering.holders.length,
    investors: await Promise.all(
      offering.holders.map(async (addr) => ({
        address: addr,
        amount: await securityToken.balanceOf(addr, 0),
        accreditationType: await getAccreditationType(addr)
      }))
    )
  };
}