GitSafe Documentation

GitSafe is the secure on-chain bank inside your GitHub, built on Solana. It gives every user a personal vault anchored to their GitHub identity, lets teams manage project workspaces and bounties entirely through issue comments, enables in-vault token swaps via Jupiter, and protects everything with soul-bound safeTokens that no AI agent, bot, or third party can drain. There is no wallet app to install, no seed phrase to manage, and no KYC.

Supported assets

Platform properties

How It Works

Every GitSafe action follows the same authenticated pipeline: from a GitHub comment to on-chain execution on Solana. Five steps, roughly 1–2 seconds end-to-end. The user never touches a wallet, signs a transaction manually, or pays gas.

Command pipeline

Getting Started

Get your GitSafe vault running in under two minutes. No wallet setup, no seed phrases, no gas. Just install the GitHub App and start commenting.

Step 1 — Install the GitHub App

Go to github.com/apps/gitsafebot and click Install. Grant access to the repositories where you want to use GitSafe. The bot will post a confirmation comment in your first enabled repository.

Step 2 — Create your vault

Open any issue in an enabled repo and comment:

@gitsafebot create vault

The bot deploys a PDA vault on Solana Mainnet anchored to your GitHub Permanent User ID. This happens once per user. Receipt includes your vault address and a Solscan link.

Step 3 — Deposit funds

@gitsafebot shield 50 USDC

The bot provides a deposit address. Send USDC (SPL) to that address. Once the transaction confirms, the bot mints safeUSDC 1:1 into your vault and posts a receipt.

Step 4 — Check your balance

@gitsafebot balance

The bot replies with your current safeToken balances and total vault value in USD.

All available commands

gitShield — Deposit

gitShield is the deposit operation. It converts external SPL tokens into soul-bound safeTokens held inside your vault PDA. The name comes from the idea of "shielding" real assets inside the GitSafe protocol.

Command syntax

@gitsafebot shield <amount> <token>

# Examples
@gitsafebot shield 100 USDC
@gitsafebot shield 0.5 SOL
@gitsafebot shield 1000 USDT

The bot replies with a deposit address specific to your vault. Send the exact token amount to that address from any Solana wallet. Once confirmed (usually 1–2 slots, ~400ms), the bot mints the equivalent safeTokens 1:1 into your vault and posts a receipt.

What happens on-chain

1. The relayer calls the shield instruction on the GitSafe program.
2. The program verifies the inbound SPL transfer was received at the vault's deposit escrow PDA.
3. The program mints the equivalent amount of the safeToken to the user's vault PDA.
4. The inbound tokens are locked in the escrow — they back the safeToken supply 1:1 at all times.
5. An event is emitted; the bot reads it and posts the receipt comment with the Solscan link.

Supported assets

Notes

• There is no minimum deposit. Any amount is accepted.
• Deposits are irrevocable via standard SPL transfer once confirmed. Use gitUnshield to withdraw.
• The deposit escrow address changes per session. Always use the address the bot provides in the current comment thread.
• Native SOL is automatically wrapped to wSOL by the relayer before shielding.

gitUnshield — Withdraw

gitUnshield is the withdrawal operation. It burns safeTokens from your vault and transfers the equivalent real SPL tokens to a destination Solana address you specify.

Command syntax

@gitsafebot unshield <amount> <token> <solana_address>

# Examples
@gitsafebot unshield 50 USDC 7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU
@gitsafebot unshield 0.1 SOL 9WzDXwBbmkg8ZTbNMqUxvQRAyrZzDsGYdLVL9zYtAWWM

What happens on-chain

1. The relayer calls the unshield instruction.
2. The program verifies the caller is the vault owner (matched via GitHub User ID in PDA seeds).
3. The safeToken amount is burned from the vault PDA.
4. The equivalent SPL tokens are released from the escrow PDA and transferred to the destination address.
5. A 0.2% fee is deducted from the withdrawn amount and sent to the fee collector PDA.

Two-step commit/reveal

For amounts above 500 USDC, GitSafe uses a commit/reveal mechanism to prevent front-running and MEV attacks:

1. The relayer commits a hash of the withdrawal details on-chain.
2. After a 1-slot delay, the relayer reveals and executes the withdrawal.
3. If the reveal does not match the commit, the program reverts.

This adds one additional slot (~400ms) to large withdrawals but ensures the destination address and amount cannot be intercepted or replaced.

Recovery address

Each vault has an optional recovery address. If set, large withdrawals above the configured threshold can only go to the recovery address. This limits the blast radius of a compromised bot token.

@gitsafebot set recovery 7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU

gitSwap — In-Vault Swap

gitSwap lets you exchange one safeToken for another without leaving your vault. The underlying SPL tokens are routed through Jupiter aggregator for best execution price, then re-minted as the target safeToken — all in a single atomic transaction.

Command syntax

@gitsafebot swap <amount> <from_token> for <to_token>

# Examples
@gitsafebot swap 100 USDC for SOL
@gitsafebot swap 0.5 SOL for USDC
@gitsafebot swap 200 USDT for JTO

Execution flow

1. The bot queries Jupiter API for the best route and slippage estimate.
2. The bot replies with a quote: expected output, price impact, and estimated fee. You confirm by replying yes or confirm.
3. The relayer calls swap on the program with the Jupiter route encoded as calldata.
4. The program unshields the source token, routes through Jupiter, and re-shields the output token — all atomically.
5. A 0.2% GitSafe fee is applied in addition to Jupiter's protocol fee.

Slippage

Default slippage tolerance is 0.5%. You can override it per swap:

@gitsafebot swap 100 USDC for SOL slippage 1%

If actual slippage exceeds the tolerance, the transaction is reverted and you keep your original tokens.

Transfer — Vault to Vault

Transfer moves safeTokens directly from your vault to another GitSafe user's vault. Because safeTokens are soul-bound and cannot be transferred via standard SPL, transfers go through the GitSafe program which burns from the sender and mints to the receiver.

Command syntax

@gitsafebot transfer <amount> <token> to @github_username

# Examples
@gitsafebot transfer 50 USDC to @alice
@gitsafebot transfer 0.1 SOL to @bob

How it works

1. The bot resolves @alice to their GitHub Permanent User ID.
2. The program verifies the recipient has an active vault PDA on-chain.
3. The safeToken amount is burned from the sender's vault.
4. An equivalent amount is minted into the recipient's vault.
5. A 0.2% fee is applied and sent to the fee collector.
6. Both sender and recipient receive a receipt comment in the thread.

Requirements

• The recipient must have an existing vault (created via @gitsafebot create vault).
• Transfers cannot be reversed. Double-check the username before confirming.
• Maximum transfer per transaction: 10,000 USDC equivalent. Larger amounts require multiple transactions.

Create a Project

A Project is a named workspace with a locked budget pool. Managers create projects, allocate a budget from their vault, and then assign portions of that budget as bounties on individual issues. When a PR merges, the payment is released automatically.

Command syntax

@gitsafebot create project "<name>" with <amount> <token> budget

# Example
@gitsafebot create project "Mobile App v2" with 500 USDC budget

What happens on-chain

1. A Project PDA is created with seeds [b"project", vault_key, name_hash].
2. The specified budget is transferred from your vault's safeUSDC balance into the project escrow PDA.
3. You are registered as the project manager. You can add additional managers with the add manager command.
4. A 0.5% install fee is deducted from the budget and sent to the treasury (see Install Fee section).

Managing the project

# Add a co-manager
@gitsafebot add manager @username to project "Mobile App v2"

# Check project budget
@gitsafebot project "Mobile App v2" balance

# Top up budget
@gitsafebot add 200 USDC to project "Mobile App v2"

# Reclaim unspent budget (manager only)
@gitsafebot reclaim project "Mobile App v2"

Assign Tasks & Bounties

Once a project is created, managers can assign individual GitHub issues as tasks with a bounty attached. The bounty is held in escrow until the linked pull request merges.

Command syntax

# Assign the current issue
@gitsafebot assign this to @contributor with 45 USDC bounty

# Assign a specific issue by number
@gitsafebot assign issue #23 to @contributor with 45 USDC bounty from project "Mobile App v2"

# Assign with deadline
@gitsafebot assign this to @contributor with 45 USDC bounty deadline 2025-09-01

Escrow mechanics

1. A Task PDA is created: [b"task", project_key, task_id].
2. The bounty amount is moved from the project escrow into the task escrow.
3. The assignee's GitHub User ID is stored in the task account.
4. Funds are locked until the task is closed by a PR merge or cancelled by a manager.

Cancelling a task

# Unassign and return funds to project budget
@gitsafebot unassign this task

Only a project manager can cancel a task. The bounty is returned to the project escrow PDA.

Auto-Pay on PR Merge

When a pull request that closes an assigned issue is merged, GitSafe automatically detects the event and releases the bounty to the contributor's vault — no manual action required.

How the detection works

1. The GitHub App listens for pull_request.closed webhook events where merged: true.
2. The bot checks the PR body and commits for closing keywords: closes #N, fixes #N, resolves #N.
3. For each matched issue, the bot looks up the on-chain task PDA.
4. The relayer calls release_bounty on the program with the PR merge event as proof.
5. The program verifies the task is still open, then mints the bounty safeTokens into the contributor's vault.
6. A 0.2% fee is deducted before release. The bot posts receipts in both the issue and the PR.

Edge cases

Install Fee & Treasury

When a project is created, a one-time 0.5% install fee is deducted from the initial project budget and sent to the GitSafe treasury PDA. This fee supports ongoing development, relayer infrastructure, and the security audit fund.

Fee example

Treasury PDA

Install fees and a portion of protocol fees accumulate in the GitSafe treasury PDA. Treasury funds are governed by the GitSafe DAO and used for:

• Relayer gas top-ups (SOL for transaction fees)
• Ongoing security audits
• Protocol development grants
• Bug bounty payouts

Top-ups do not incur install fees

Adding additional budget to an existing project does not trigger another install fee. Only the initial project creation incurs the 0.5% charge.

Identity Anchoring

GitSafe anchors every vault to a GitHub Permanent User ID — an immutable integer assigned by GitHub at account creation time. This is the core security primitive that makes GitSafe safe for AI agents.

Why Permanent User ID, not username

GitHub usernames can be changed, transferred, or reclaimed. If vault ownership were tied to a username, an attacker could rename their account to a target username after the original owner renamed theirs, then claim ownership of the vault.

The Permanent User ID cannot be changed by the user, cannot be transferred, and cannot be claimed by another account. It is the only GitHub identity primitive safe to use as an on-chain key.

How the ID becomes a PDA

// Vault PDA derivation (Anchor)
let (vault_pda, bump) = Pubkey::find_program_address(
    &[b"vault", &github_uid.to_le_bytes()],
    &program_id,
);

The same Permanent User ID always produces the same vault address on Solana. There is no mapping table and no registry — the address is deterministic.

Webhook verification

The GitHub webhook payload includes sender.id (the Permanent User ID) alongside sender.login (the username). The bot exclusively uses sender.id to look up vaults. Username spoofing via a renamed account is structurally impossible in this model.

Soul-Bound Tokens

safeTokens are SPL tokens whose transfer authority is permanently set to the GitSafe program PDA. No external wallet, agent, or attacker can initiate a transfer. Only the GitSafe program can move them — and only via verified instructions.

How they differ from standard SPL tokens

Attack scenarios eliminated

• Phishing signatures — There is no transaction to sign that moves safeTokens. A phishing site cannot construct a valid transfer.
• Compromised AI agent — Even with full bot access and a valid relayer key, an agent cannot call a transfer instruction on safeTokens directly.
• Malicious approve — No approve function exists. There is no attack surface for draining via a delegate.
• Rug by deployer — The program upgrade authority will be revoked after audit. Even the GitSafe team cannot drain vaults.

Recovery

GitSafe provides two recovery mechanisms to ensure users are never permanently locked out of their vault.

Recovery address

You can designate a recovery address — any Solana wallet you control. If you lose access to the GitHub account that owns your vault, the recovery address can initiate a time-locked vault migration.

@gitsafebot set recovery 7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU

Recovery is time-locked for 72 hours after initiation. During this window, the original vault owner can cancel the recovery by commenting in any enabled repository. This prevents an attacker who compromises your recovery wallet from immediately draining funds.

Key rotation

If you suspect your GitHub account is compromised, you can rotate the signing key used by the relayer for your vault:

@gitsafebot rotate signing key

This generates a new relayer sub-key pair for your vault and stores the public key on-chain. Old keys are immediately revoked.

Emergency exit

After 6 months of vault inactivity, the program allows the recovery address to withdraw all assets without the standard relayer flow. This ensures funds are never permanently stranded if GitSafe shuts down or the bot becomes unavailable.

The emergency exit bypasses the GitSafe bot entirely and interacts with the on-chain program directly via any Solana wallet client.

Fee Structure

GitSafe charges a flat 0.2% protocol fee on value-moving operations. There are no subscription fees, no monthly charges, and no hidden costs. The relayer pays all Solana network fees on behalf of users.

Fee example — bounty workflow

# Manager creates project with 1000 USDC
Install fee: 0.5% = 5 USDC  →  available budget: 995 USDC

# Manager assigns 100 USDC bounty
100 USDC escrowed in task PDA

# PR merged, bounty released to contributor
Protocol fee: 0.2% = 0.20 USDC
Contributor receives: 99.80 USDC

Relayer

The relayer is a trusted service operated by GitSafe that bridges GitHub webhook events to Solana transactions. It holds a funded Solana wallet that signs and broadcasts all on-chain instructions on behalf of users.

Why a relayer?

Solana requires all transactions to be signed by a funded keypair that pays the transaction fee (~0.000005 SOL). Since users interact via GitHub comments and may not hold any SOL, the relayer acts as the transaction fee payer and broadcaster, enabling a gasless experience.

What the relayer can and cannot do

Relayer uptime and fallback

The GitSafe relayer targets 99.9% uptime. If the relayer is unavailable, users can interact with the program directly using the CLI (gitsafe) or any Solana wallet with the IDL loaded. The emergency exit path is always available on-chain regardless of relayer status.

Fee Collector

Protocol fees accumulate in the fee collector PDA, a program-derived address controlled exclusively by the GitSafe DAO multisig. Fees are denominated in the token being transacted (USDC fees stay as USDC, SOL fees stay as SOL).

Fee collector address

// Fee collector PDA derivation
let (fee_collector, _) = Pubkey::find_program_address(
    &[b"fee_collector"],
    &program_id,
);

Fee distribution

Distribution is governed by the GitSafe DAO and can be adjusted via on-chain governance vote. All fee flows are publicly verifiable on Solscan.

AI Agent Wallet

GitSafe is the only on-chain bank account designed for AI agents. Because safeTokens are soul-bound and the program enforces permissions at the instruction level, you can give an agent full bot access without risking vault drainage.

How agent access works

An AI agent operates through the same IssueOps interface as a human: by commenting @gitsafebot <command> in GitHub issues. The agent must have a GitHub token with comment permissions on the repository.

# Typical agent workflow
# 1. Agent detects a completed task
# 2. Agent comments to release payment
@gitsafebot assign issue #47 to @contributor with 30 USDC bounty

# 3. PR merges → auto-pay fires
# 4. Agent checks project balance
@gitsafebot project "Sprint 3" balance

Security properties for agents

• No drain path — safeTokens cannot be transferred by the agent directly. Even with a stolen GitHub token, there is no instruction to call.
• Rate limiting — The bot enforces per-user command rate limits. A runaway agent cannot spam transactions.
• Manager-only operations — Budget allocation and project creation require manager role. Give agents contributor-level access only if they should not control budget.
• Confidence threshold — Claude Haiku's confidence score must exceed 0.92 for any financial operation. Ambiguous agent commands are rejected with a clarification request.

Recommended agent pattern

// Pseudocode: agent bounty automation
async function onPRMerge(pr) {
  const issue = await getLinkedIssue(pr);
  const contributor = issue.assignee.login;
  const bounty = await estimateBounty(issue.complexity);
  
  // Agent posts the command — GitSafe program handles payment
  await ghComment(issue.number,
    `@gitsafebot assign this to @${contributor} with ${bounty} USDC bounty`
  );
}

Trading Bot Integration

GitSafe vaults can serve as the treasury for autonomous trading bots. The bot can execute swaps and check balances, but cannot drain the vault or transfer funds to external addresses without a verified GitHub identity check.

Setup

1. Create a dedicated GitHub account for your bot (e.g. myproject-treasury-bot).
2. Create a vault for that account: @gitsafebot create vault.
3. Fund the vault via gitShield.
4. Give the bot a GitHub token with issues:write and pull_requests:write permissions on the repo.
5. The bot comments @gitsafebot swap ... to rebalance.

Rate limits

Webhook integration

If you run your own bot service, you can subscribe to GitSafe program events via a Solana WebSocket connection and react to on-chain state changes without polling GitHub comments:

const ws = new WebSocket('wss://api.mainnet-beta.solana.com');
ws.send(JSON.stringify({
  jsonrpc: '2.0', id: 1,
  method: 'logsSubscribe',
  params: [{ mentions: ['GSaFe11111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'] }]
}));

Contract Reference

The GitSafe program is written in Rust using the Anchor framework. All accounts use PDA derivation. The program is open-source under Apache 2.0.

Program ID

GSaFe11111xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Instructions

Account structures

#[account]
pub struct Vault {
    pub github_uid: u64,          // GitHub Permanent User ID
    pub bump: u8,                  // PDA bump
    pub recovery: Option<Pubkey>, // Optional recovery address
    pub created_at: i64,          // Unix timestamp
    pub last_active: i64,         // For emergency exit timer
}

#[account]
pub struct Project {
    pub vault: Pubkey,            // Owner vault
    pub name_hash: [u8; 32],     // SHA256 of project name
    pub token_mint: Pubkey,       // Budget token (e.g. USDC)
    pub budget: u64,             // Remaining budget
    pub managers: Vec<u64>,     // GitHub UIDs of managers
}

#[account]
pub struct Task {
    pub project: Pubkey,         // Parent project
    pub task_id: u64,            // GitHub issue number
    pub assignee_uid: u64,       // Assignee GitHub UID
    pub bounty: u64,             // Escrowed amount
    pub closed: bool,            // Released or cancelled
}

Security for Agents

GitSafe is the only on-chain bank where giving an AI agent vault access does not require trusting the agent's integrity. Security is enforced at the Solana program level, not at the application level.

Threat model

Recommended permissions for agents

• Contributor role only — unless the agent needs to manage budgets, do not add it as a project manager.
• Separate vault per agent — create a dedicated GitHub account per agent and fund it with limited budget.
• Set a recovery address — point to a hardware wallet you control. If the agent misbehaves, recovery gives you a time-locked escape.
• Monitor Solscan events — subscribe to program events for the agent's vault to detect anomalies in real time.

CLI (gitsafe)

The gitsafe CLI lets you interact with your vault directly from the terminal, without going through GitHub issue comments. Useful for power users, CI/CD pipelines, and emergency access when the bot is unavailable.

Installation

# Via npm
npm install -g @gitsafe/cli

# Via Homebrew (macOS)
brew install gitsafe-cli

# Verify
gitsafe --version

Authentication

# Authenticate with GitHub (opens browser)
gitsafe auth login

# Or provide a token directly
gitsafe auth login --token ghp_xxxxxxxxxxxx

Commands

Config file

# ~/.gitsafe/config.yaml
rpc_url: https://api.mainnet-beta.solana.com
network: mainnet
github_token: ghp_xxxxxxxxxxxx
default_slippage: 0.5

SDK (@gitsafe-agent/sdk)

The TypeScript SDK lets you integrate GitSafe vault operations into your own applications, bots, and agents without going through GitHub issue comments.

Installation

npm install @gitsafe-agent/sdk @solana/web3.js

Initialization

import { GitSafeClient } from '@gitsafe-agent/sdk';
import { Connection, clusterApiUrl } from '@solana/web3.js';

const client = new GitSafeClient({
  connection: new Connection(clusterApiUrl('mainnet-beta')),
  githubToken: process.env.GITHUB_TOKEN,
  relayerUrl: 'https://relay.gitsafe.io',
});

Vault operations

// Get vault address for a GitHub user
const vault = await client.vault.getAddress('octocat');

// Fetch balances
const balances = await client.vault.getBalances('octocat');
// → { safeUSDC: 150.00, safeSOL: 0.42, usdValue: 217.80 }

// Shield (deposit)
const tx = await client.vault.shield({
  user: 'octocat',
  amount: 50,
  token: 'USDC',
});

// Unshield (withdraw)
const tx = await client.vault.unshield({
  user: 'octocat',
  amount: 25,
  token: 'USDC',
  destination: '7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU',
});

// Swap via Jupiter
const quote = await client.vault.getSwapQuote({ from: 'USDC', to: 'SOL', amount: 100 });
const tx    = await client.vault.swap({ user: 'octocat', quote });

Project operations

// Create project
await client.project.create({
  manager: 'octocat',
  name: 'Sprint 4',
  budget: 500,
  token: 'USDC',
});

// Assign bounty
await client.task.assign({
  project: 'Sprint 4',
  issueNumber: 47,
  assignee: 'alice',
  bounty: 45,
  token: 'USDC',
});

// Listen for PR merge events → auto release
client.tasks.onMerge(async (event) => {
  await client.task.release(event.taskId);
});

Glossary

FAQ

Is GitSafe safe to use with an AI agent?

Yes. safeTokens have no transfer or approve instruction. An AI agent with full GitHub bot access and even a compromised relayer key cannot drain your vault. The program enforces ownership at the instruction level — there is simply no function to call that would move your funds without a verified GitHub User ID match.

What happens if GitSafe shuts down?

Your funds are held in on-chain PDAs, not by GitSafe. If GitSafe discontinues operations: (1) the program remains deployed — Solana programs cannot be deleted by their deployer once the upgrade authority is revoked; (2) the CLI and SDK can interact with the program directly without the relayer; (3) the emergency exit path allows recovery via the recovery address after 6 months of inactivity.

Can GitSafe access my funds?

No. The program's upgrade authority will be transferred to the GitSafe DAO multisig after the security audit, and then revoked entirely. After revocation, the team cannot modify the program or access vault funds.

Do I need to hold SOL to use GitSafe?

No. The GitSafe relayer pays all Solana transaction fees (~$0.00025 per transaction) on your behalf. You only need the tokens you want to deposit.

What is the minimum deposit?

There is no minimum deposit amount. Any amount of any supported SPL token is accepted.

Why Solana and not Ethereum or Base?

Solana's transaction costs (~$0.00025 per tx) make automated bounty payments economically viable at any size. On Ethereum mainnet, a $5 bounty could cost $2–10 in gas. Base is cheaper but still an order of magnitude more expensive than Solana. For developer payments that need to scale to hundreds of daily transactions across many repositories, Solana is the only viable option.

Can I use GitSafe without installing the GitHub App?

The GitHub App is required for bot comment parsing and webhook events. However, the CLI and SDK can interact with the Solana program directly without the App for advanced use cases.

What happens if I rename my GitHub username?

Nothing. Your vault is anchored to your GitHub Permanent User ID, not your username. Renaming your account does not affect vault ownership or access.

Is there a maximum vault size?

There is no enforced limit. The program handles arbitrary balances for each supported token. Practical limits are set by available liquidity for gitSwap operations.

How do I report a security vulnerability?

Email security@gitsafe.io with a detailed description. Critical vulnerabilities receive a reward from the bug bounty fund. Do not disclose publicly before we have had 72 hours to respond.

Can I have multiple vaults?

One vault per GitHub account. To manage separate budgets, use the Projects feature — each project has its own escrow PDA with independent accounting.

Roadmap

GitSafe is launching soon on Solana Mainnet. Here is what is planned:

Phase 1 — Foundation (Q3 2025)

• Solana Anchor program deployment
• GitHub App (webhook + AI parser)
• gitShield / gitUnshield (deposit/withdraw)
• safeUSDC + safeSOL soul-bound tokens
• Gasless relayer infrastructure

Phase 2 — Projects & Bounties (Q4 2025)

• Project workspaces with budget escrow
• Task assignment + bounty locking
• Auto-pay on PR merge
• gitSwap via Jupiter aggregator
• Vault-to-vault transfers

Phase 3 — Scale (Q1 2026)

• CLI (gitsafe) + TypeScript SDK
• Security audit + upgrade authority revocation
• Web dashboard (read-only vault view)
• Multi-repo project support

Phase 4 — DeFi & Ecosystem (Q2 2026)

• Yield on idle vault assets (Jito staking)
• GitSafe DAO + treasury multisig
• $GITSAFE token launch
• GitLab + Bitbucket support