@gl-36/sdk 0.0.0-stage → 0.1.0

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from "./constants.ts";
+export * from "./account.ts";
+export * from "./pda.ts";
+export * from "./instructions.ts";
+export * from "./errors.ts";
+export * from "./logs.ts";
+export * from "./price.ts";
+export * from "./seed.ts";
+export * from "./rpc.ts";

package/src/instructions.ts

@@ -0,0 +1,186 @@
+import { AccountRole, type Address, type Instruction, type TransactionSigner } from "@solana/kit";
+import { MAX_FEE_BPS, MAX_MINT_BATCH, MAX_PRICE, MAX_SUPPLY, SLOT_HASHES, SYSTEM_PROGRAM } from "./constants.ts";
+
+export const INSTRUCTION = {
+  init: 0,
+  mint: 1,
+  transfer: 2,
+  list: 3,
+  buy: 4,
+  close: 5,
+  withdrawExcess: 6,
+  settle: 7,
+} as const;
+
+export interface InitArgs {
+  nonce: number;
+  maxSupply: number;
+  feeBps: number;
+  mintPrice: bigint;
+  generatorHash: Uint8Array;
+}
+
+class Writer {
+  buf: Uint8Array;
+  view: DataView;
+  off = 0;
+  constructor(len: number) {
+    this.buf = new Uint8Array(len);
+    this.view = new DataView(this.buf.buffer);
+  }
+  u8(v: number) {
+    this.view.setUint8(this.off, v);
+    this.off += 1;
+    return this;
+  }
+  u16(v: number) {
+    this.view.setUint16(this.off, v, true);
+    this.off += 2;
+    return this;
+  }
+  u32(v: number) {
+    this.view.setUint32(this.off, v, true);
+    this.off += 4;
+    return this;
+  }
+  u64(v: bigint) {
+    this.view.setBigUint64(this.off, v, true);
+    this.off += 8;
+    return this;
+  }
+  bytes(b: Uint8Array) {
+    this.buf.set(b, this.off);
+    this.off += b.length;
+    return this;
+  }
+}
+
+function int(name: string, v: number, min: number, max: number) {
+  if (!Number.isInteger(v) || v < min || v > max) throw new RangeError(`${name} must be an integer from ${min} to ${max}, got ${v}`);
+}
+
+function bytes32(name: string, b: Uint8Array) {
+  if (b.length !== 32) throw new RangeError(`${name} must be 32 bytes, got ${b.length}`);
+}
+
+const signer = (s: TransactionSigner, writable: boolean) => ({
+  address: s.address,
+  role: writable ? AccountRole.WRITABLE_SIGNER : AccountRole.READONLY_SIGNER,
+  signer: s,
+});
+const w = (address: Address) => ({ address, role: AccountRole.WRITABLE });
+const r = (address: Address) => ({ address, role: AccountRole.READONLY });
+
+export function initIx(
+  programId: Address,
+  creator: TransactionSigner,
+  collection: Address,
+  treasury: Address,
+  a: InitArgs,
+): Instruction {
+  int("nonce", a.nonce, 0, 0xffff_ffff);
+  int("maxSupply", a.maxSupply, 1, MAX_SUPPLY);
+  int("feeBps", a.feeBps, 0, MAX_FEE_BPS);
+  if (a.mintPrice < 0n || a.mintPrice > 0xffff_ffff_ffff_ffffn) throw new RangeError(`mintPrice must be a u64, got ${a.mintPrice}`);
+  bytes32("generatorHash", a.generatorHash);
+  const data = new Writer(49)
+    .u8(INSTRUCTION.init)
+    .u32(a.nonce)
+    .u16(a.maxSupply)
+    .u16(a.feeBps)
+    .u64(a.mintPrice)
+    .bytes(a.generatorHash).buf;
+  return {
+    programAddress: programId,
+    accounts: [signer(creator, true), w(collection), r(treasury), r(SYSTEM_PROGRAM)],
+    data,
+  };
+}
+
+export function mintIx(
+  programId: Address,
+  minter: TransactionSigner,
+  collection: Address,
+  creator: Address,
+  count: number,
+): Instruction {
+  int("count", count, 1, MAX_MINT_BATCH);
+  return {
+    programAddress: programId,
+    accounts: [signer(minter, true), w(collection), w(creator), r(SYSTEM_PROGRAM)],
+    data: new Writer(2).u8(INSTRUCTION.mint).u8(count).buf,
+  };
+}
+
+export function transferIx(
+  programId: Address,
+  owner: TransactionSigner,
+  collection: Address,
+  newOwner: Address,
+  id: number,
+): Instruction {
+  int("id", id, 0, MAX_SUPPLY - 1);
+  return {
+    programAddress: programId,
+    accounts: [signer(owner, false), w(collection), r(newOwner)],
+    data: new Writer(3).u8(INSTRUCTION.transfer).u16(id).buf,
+  };
+}
+
+export function listIx(
+  programId: Address,
+  owner: TransactionSigner,
+  collection: Address,
+  id: number,
+  price: number,
+): Instruction {
+  int("id", id, 0, MAX_SUPPLY - 1);
+  int("price", price, 0, MAX_PRICE);
+  return {
+    programAddress: programId,
+    accounts: [signer(owner, false), w(collection)],
+    data: new Writer(7).u8(INSTRUCTION.list).u16(id).u32(price).buf,
+  };
+}
+
+export function buyIx(
+  programId: Address,
+  buyer: TransactionSigner,
+  collection: Address,
+  seller: Address,
+  treasury: Address,
+  id: number,
+  maxPrice: number,
+): Instruction {
+  int("id", id, 0, MAX_SUPPLY - 1);
+  int("maxPrice", maxPrice, 1, MAX_PRICE);
+  return {
+    programAddress: programId,
+    accounts: [signer(buyer, true), w(collection), w(seller), w(treasury), r(SYSTEM_PROGRAM)],
+    data: new Writer(7).u8(INSTRUCTION.buy).u16(id).u32(maxPrice).buf,
+  };
+}
+
+export function closeIx(programId: Address, creator: TransactionSigner, collection: Address): Instruction {
+  return {
+    programAddress: programId,
+    accounts: [signer(creator, false), w(collection)],
+    data: new Uint8Array([INSTRUCTION.close]),
+  };
+}
+
+export function settleIx(programId: Address, collection: Address): Instruction {
+  return {
+    programAddress: programId,
+    accounts: [w(collection), r(SLOT_HASHES)],
+    data: new Uint8Array([INSTRUCTION.settle]),
+  };
+}
+
+export function withdrawExcessIx(programId: Address, creator: TransactionSigner, collection: Address): Instruction {
+  return {
+    programAddress: programId,
+    accounts: [signer(creator, true), w(collection)],
+    data: new Uint8Array([INSTRUCTION.withdrawExcess]),
+  };
+}

package/src/logs.ts

@@ -0,0 +1,77 @@
+import type { Address } from "@solana/kit";
+
+export type Gl36Event =
+  | { type: "init"; maxSupply: number }
+  | { type: "mint"; firstId: number; count: number }
+  | { type: "transfer"; id: number }
+  | { type: "list"; id: number; price: number }
+  | { type: "buy"; id: number; price: number }
+  | { type: "close"; minted: number }
+  | { type: "settle" }
+  | { type: "rearm" }
+  | { type: "withdraw"; lamports: bigint };
+
+const INVOKE = /^Program (\w+) invoke \[\d+\]$/;
+const EXIT = /^Program (\w+) (success|failed)/;
+const LOG = "Program log: ";
+
+const ints = (parts: string[], n: number) =>
+  parts.length === n && parts.every((p) => /^\d+$/.test(p)) ? parts.map(Number) : null;
+
+function parseEvent(message: string): Gl36Event | null {
+  const [kind, ...rest] = message.trim().split(/\s+/);
+  switch (kind) {
+    case "init": {
+      const v = ints(rest, 1);
+      return v && { type: "init", maxSupply: v[0] };
+    }
+    case "mint": {
+      const v = ints(rest, 2);
+      return v && { type: "mint", firstId: v[0], count: v[1] };
+    }
+    case "xfer": {
+      const v = ints(rest, 1);
+      return v && { type: "transfer", id: v[0] };
+    }
+    case "list": {
+      const v = ints(rest, 2);
+      return v && { type: "list", id: v[0], price: v[1] };
+    }
+    case "buy": {
+      const v = ints(rest, 2);
+      return v && { type: "buy", id: v[0], price: v[1] };
+    }
+    case "close": {
+      const v = ints(rest, 1);
+      return v && { type: "close", minted: v[0] };
+    }
+    case "settle":
+      return rest.length === 0 ? { type: "settle" } : null;
+    case "rearm":
+      return rest.length === 0 ? { type: "rearm" } : null;
+    case "withdraw":
+      return rest.length === 1 && /^\d+$/.test(rest[0]) ? { type: "withdraw", lamports: BigInt(rest[0]) } : null;
+    default:
+      return null;
+  }
+}
+
+export function parseLogs(logs: readonly string[], programId: Address): Gl36Event[] {
+  const stack: string[] = [];
+  const events: Gl36Event[] = [];
+  for (const line of logs) {
+    const invoke = INVOKE.exec(line);
+    if (invoke) {
+      stack.push(invoke[1]);
+      continue;
+    }
+    if (EXIT.test(line)) {
+      stack.pop();
+      continue;
+    }
+    if (stack.at(-1) !== programId || !line.startsWith(LOG)) continue;
+    const event = parseEvent(line.slice(LOG.length));
+    if (event) events.push(event);
+  }
+  return events;
+}

package/src/pda.ts

@@ -0,0 +1,14 @@
+import { getAddressEncoder, getProgramDerivedAddress, type Address } from "@solana/kit";
+
+export async function findCollection(programId: Address, creator: Address, nonce: number): Promise<[Address, number]> {
+  if (!Number.isInteger(nonce) || nonce < 0 || nonce > 0xffff_ffff) {
+    throw new RangeError(`nonce must be a u32, got ${nonce}`);
+  }
+  const n = new Uint8Array(4);
+  new DataView(n.buffer).setUint32(0, nonce, true);
+  const [pda, bump] = await getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [new TextEncoder().encode("col"), getAddressEncoder().encode(creator), n],
+  });
+  return [pda, bump];
+}

package/src/price.ts

@@ -0,0 +1,39 @@
+import { MAX_PRICE, PRICE_UNIT } from "./constants.ts";
+
+const DECIMALS = 6;
+
+function check(price: number) {
+  if (!Number.isInteger(price) || price < 0 || price > MAX_PRICE) {
+    throw new RangeError(`price must be an integer from 0 to ${MAX_PRICE} units of 1,000 lamports, got ${price}`);
+  }
+}
+
+export function priceToLamports(price: number): bigint {
+  check(price);
+  return BigInt(price) * PRICE_UNIT;
+}
+
+export function lamportsToPrice(lamports: bigint): number {
+  if (lamports % PRICE_UNIT !== 0n) throw new RangeError(`${lamports} lamports is not a whole number of price units`);
+  const price = lamports / PRICE_UNIT;
+  if (price < 0n || price > BigInt(MAX_PRICE)) throw new RangeError(`${lamports} lamports is outside the u32 price range`);
+  return Number(price);
+}
+
+export function solToPrice(sol: string | number): number {
+  const text = typeof sol === "number" ? sol.toFixed(DECIMALS) : sol.trim();
+  const m = /^(\d*)(?:[.,](\d*))?$/.exec(text);
+  if (!m || (m[1] === "" && !m[2])) throw new RangeError(`not a SOL amount: ${sol}`);
+  const frac = (m[2] ?? "").replace(/0+$/, "");
+  if (frac.length > DECIMALS) throw new RangeError(`prices go down to 0.000001 SOL, got ${sol}`);
+  const price = Number(BigInt(m[1] || "0") * 10n ** BigInt(DECIMALS) + BigInt(frac.padEnd(DECIMALS, "0") || "0"));
+  check(price);
+  return price;
+}
+
+export function priceToSol(price: number): string {
+  check(price);
+  const whole = Math.floor(price / 10 ** DECIMALS);
+  const frac = String(price % 10 ** DECIMALS).padStart(DECIMALS, "0").replace(/0+$/, "");
+  return frac ? `${whole}.${frac}` : String(whole);
+}

package/src/rpc.ts

@@ -0,0 +1,127 @@
+import {
+  getBase58Decoder,
+  getBase64Encoder,
+  type Address,
+  type Base58EncodedBytes,
+  type Commitment,
+  type GetAccountInfoApi,
+  type GetMinimumBalanceForRentExemptionApi,
+  type GetProgramAccountsApi,
+  type Rpc,
+} from "@solana/kit";
+import {
+  decodeCollection,
+  decodeHeader,
+  decodeSlot,
+  slotOffset,
+  type Collection,
+  type CollectionHeader,
+  type Slot,
+} from "./account.ts";
+import { ACCOUNT_OVERHEAD, COLLECTION_TAG, HEADER_LEN, HEADER_OFFSET, LAYOUT_VERSION, SLOT_LEN } from "./constants.ts";
+
+export interface FetchConfig {
+  commitment?: Commitment;
+  programId?: Address;
+}
+
+export interface FetchedCollection {
+  address: Address;
+  lamports: bigint;
+  data: Uint8Array;
+  collection: Collection;
+}
+
+const bytes = (base64: string) => new Uint8Array(getBase64Encoder().encode(base64));
+
+function owned(owner: Address, programId: Address | undefined, address: Address) {
+  if (programId !== undefined && owner !== programId) {
+    throw new Error(`${address} is owned by ${owner}, not by the GL-36 program ${programId}`);
+  }
+}
+
+export async function fetchCollection(
+  rpc: Rpc<GetAccountInfoApi>,
+  address: Address,
+  config: FetchConfig = {},
+): Promise<FetchedCollection | null> {
+  const { value } = await rpc
+    .getAccountInfo(address, { encoding: "base64", commitment: config.commitment ?? "confirmed" })
+    .send();
+  if (!value) return null;
+  owned(value.owner, config.programId, address);
+  const data = bytes(value.data[0]);
+  return { address, lamports: BigInt(value.lamports), data, collection: decodeCollection(data) };
+}
+
+export async function fetchHeader(
+  rpc: Rpc<GetAccountInfoApi>,
+  address: Address,
+  config: FetchConfig = {},
+): Promise<CollectionHeader | null> {
+  const { value } = await rpc
+    .getAccountInfo(address, {
+      encoding: "base64",
+      commitment: config.commitment ?? "confirmed",
+      dataSlice: { offset: 0, length: HEADER_LEN },
+    })
+    .send();
+  if (!value) return null;
+  owned(value.owner, config.programId, address);
+  return decodeHeader(bytes(value.data[0]));
+}
+
+export async function fetchSlot(
+  rpc: Rpc<GetAccountInfoApi>,
+  address: Address,
+  id: number,
+  config: FetchConfig = {},
+): Promise<Slot | null> {
+  const { value } = await rpc
+    .getAccountInfo(address, {
+      encoding: "base64",
+      commitment: config.commitment ?? "confirmed",
+      dataSlice: { offset: slotOffset(id), length: SLOT_LEN },
+    })
+    .send();
+  if (!value) return null;
+  owned(value.owner, config.programId, address);
+  const data = bytes(value.data[0]);
+  return data.length < SLOT_LEN ? null : decodeSlot(data, id);
+}
+
+export interface FoundCollection {
+  address: Address;
+  header: CollectionHeader;
+}
+
+export async function findCollections(
+  rpc: Rpc<GetProgramAccountsApi>,
+  programId: Address,
+  options: { creator?: Address; commitment?: Commitment } = {},
+): Promise<FoundCollection[]> {
+  const tagAndVersion = getBase58Decoder().decode(new Uint8Array([COLLECTION_TAG, LAYOUT_VERSION])) as Base58EncodedBytes;
+  const filters = [
+    { memcmp: { offset: 0n, bytes: tagAndVersion, encoding: "base58" as const } },
+    ...(options.creator
+      ? [{ memcmp: { offset: BigInt(HEADER_OFFSET.creator), bytes: options.creator as string as Base58EncodedBytes, encoding: "base58" as const } }]
+      : []),
+  ];
+  const accounts = (await rpc
+    .getProgramAccounts(programId, {
+      encoding: "base64",
+      commitment: options.commitment ?? "confirmed",
+      dataSlice: { offset: 0, length: HEADER_LEN },
+      filters,
+    })
+    .send()) as unknown as readonly { pubkey: Address; account: { data: readonly [string, string] } }[];
+  return accounts.map(({ pubkey, account }) => ({ address: pubkey, header: decodeHeader(bytes(account.data[0])) }));
+}
+
+export async function getLamportsPerByte(rpc: Rpc<GetMinimumBalanceForRentExemptionApi>): Promise<bigint> {
+  const min = await rpc.getMinimumBalanceForRentExemption(0n).send();
+  return BigInt(min) / BigInt(ACCOUNT_OVERHEAD);
+}
+
+export const rentExemptMinimum = (dataLength: number, lamportsPerByte: bigint): bigint =>
+  BigInt(ACCOUNT_OVERHEAD + dataLength) * lamportsPerByte;

package/src/seed.ts

@@ -0,0 +1,30 @@
+import { getAddressEncoder, type Address } from "@solana/kit";
+import { MAX_SUPPLY } from "./constants.ts";
+
+async function sha256(...parts: Uint8Array[]): Promise<Uint8Array> {
+  const buf = new Uint8Array(new ArrayBuffer(parts.reduce((n, p) => n + p.length, 0)));
+  let off = 0;
+  for (const p of parts) {
+    buf.set(p, off);
+    off += p.length;
+  }
+  return new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", buf));
+}
+
+export interface TokenSeedArgs {
+  domain: string;
+  collection: Address;
+  entropy: Uint8Array;
+  id: number;
+}
+
+export function tokenSeed({ domain, collection, entropy, id }: TokenSeedArgs): Promise<Uint8Array> {
+  if (!Number.isInteger(id) || id < 0 || id >= MAX_SUPPLY) throw new RangeError(`id must be a u16 below ${MAX_SUPPLY}, got ${id}`);
+  const idLe = new Uint8Array([id & 0xff, id >> 8]);
+  return sha256(
+    new TextEncoder().encode(domain),
+    new Uint8Array(getAddressEncoder().encode(collection)),
+    entropy,
+    idLe,
+  );
+}