open-index/open-npm huggingface dataset:
npm package: @sanctuary-framework/quickstart
Description: Zero-friction agent onboarding for Sanctuary Framework. Generate an Ed25519 identity and publish a sovereign agent profile to Verascore in under 60 seconds.
Author: Erik Newton
Latest version: 0.1.0

# @sanctuary-framework/quickstart

Zero-friction agent onboarding for the Sanctuary Framework. Generate an Ed25519 sovereign identity, publish an agent profile to Verascore, and get a live profile URL in under 60 seconds.

## Usage

```bash
npx @sanctuary-framework/quickstart
```

With flags (non-interactive):

```bash
npx @sanctuary-framework/quickstart --name="My Agent" --yes
```

## What it does

1. Generates an Ed25519 keypair.
2. Derives a `did:key` DID from the public key (multicodec `0xed01`, base64url).
3. Saves the identity to `~/.sanctuary/quickstart-identity.json` (mode `0600`).
4. Builds a minimal Sovereignty Health Report (SHR).
5. Signs the payload and POSTs it to `https://verascore.ai/api/publish`.
6. Prints the live profile URL.

## Identity format

The identity file on disk:

```json
{
  "did": "did:key:z...",
  "publicKey": "<base64url>",
  "privateKey": "<base64url>",
  "createdAt": "2026-04-04T..."
}
```

The DID encoding matches Sanctuary's full identity subsystem (`server/src/core/identity.ts`), so quickstart identities are forward-compatible with the full Sanctuary MCP server.

## Environment variables

- `VERASCORE_URL` — override the Verascore endpoint (default: `https://verascore.ai`).

## Upgrade path

Once you have a Verascore profile, install the full Sanctuary MCP server:

```bash
npm install -g @sanctuary-framework/mcp-server
```

## License

Apache-2.0
npm package: @sanctumso/inf1
Description: Typescript + WASM SDK for Sanctum Infinity program V1.
Latest version: 0.0.2-dev-4

# @sanctumso/inf1

Typescript + WASM SDK for Sanctum Infinity program V1.

## Example Usage

```ts
import {
  assertAccountsExist,
  createSolanaRpc,
  fetchEncodedAccounts,
  type Address,
  type IInstruction,
  type Rpc,
  type SolanaRpcApi,
} from "@solana/kit";
import {
  accountsToUpdateForTrade,
  init,
  initPks,
  quoteTradeExactIn,
  tradeExactInIx,
  updateForTrade,
  type AccountMap,
  type SplPoolAccounts,
} from "@sanctumso/inf1";
import initSdk from "@sanctumso/inf1";

// The SDK needs to be initialized once globally before it can be used (idempotent).
// For nodejs environments, use
// `import { initSyncEmbed } from "@sanctumso/inf1"; initSyncEmbed();`
// instead
await initSdk();

const LAINESOL = "LAinEtNLgpmCP9Rvsf5Hn8W6EhNiKLZQti1xfWMLy6X";
const WSOL = "So11111111111111111111111111111111111111112";
const SPL_POOL_ACCOUNTS: SplPoolAccounts = new Map(Object.entries({
  [LAINESOL]: "2qyEeSAWKfU18AFthrF7JA8z8ZCi1yt76Tqs917vwQTV",
  // ...populate rest of `spl lst mint: stake pool addr` data
  // for every spl lst mints in the INF pool (all 3 spl program deploys).
  // To support SPL LSTs that are added later on, the `appendSplLsts` fn
  // can be used to add data
}));

// If out === INF mint, then below code will work the same,
// but the quote and instruction will be for AddLiquidity instead of SwapExactIn.
//
// If inp === INF mint, then below code will work the same,
// but the quote and instruction will be for RemoveLiquidity instead of SwapExactIn.
const SWAP_MINTS = { inp: LAINESOL, out: WSOL };

async function fetchAccountMap(
  rpc: Rpc<SolanaRpcApi>,
  accounts: string[]
): Promise<AccountMap> {
  const fetched = await fetchEncodedAccounts(rpc, accounts);
  assertAccountsExist(fetched);
  return new Map(
    fetched.map(({ address, data, programAddress }) => [
      address,
      { data, owner: programAddress },
    ])
  );
}

const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");

// init
const ipks = initPks();
const initAccs = await fetchAccountMap(rpc, ipks);
const inf = init(
  initAccs,
  SPL_POOL_ACCOUNTS
);

// update
const updateAccs = await fetchAccountMap(
  rpc,
  accountsToUpdateForTrade(inf, SWAP_MINTS)
);
updateForTrade(inf, SWAP_MINTS, updateAccs);

// quote
const amt = 1_000_000_000n;
const quote = quoteTradeExactIn(inf, {
  amt,
  mints: SWAP_MINTS,
});

// create transaction instruction

// user-provided pubkeys
const signer = ...;
const inpTokenAcc = ...;
const outTokenAcc = ...;

const ixUncasted = tradeExactInIx(inf, {
  amt,
  limit: quote.out,
  mints: SWAP_MINTS,
  signer,
  tokenAccs: {
    inp: inpTokenAcc,
    out: outTokenAcc,
  },
});
// return type is compatible with kit,
// but needs to be casted explicitly
const ix = ixUncasted as unknown as IInstruction;
```

## Build

### Prerequisites

- [`wasm-pack`](https://rustwasm.github.io/wasm-pack/)
- `make` (optional, you can just run the `wasm-pack` commands manually)