@shunt-network/sdk 1.0.0

package/src/clients/typescript/src/safe-codecs.ts

@@ -0,0 +1,82 @@
+// Drop-in replacement for @solana/kit's number codecs, wired in via
+// codama's dependencyMap. Re-exports everything unchanged except the
+// u64/u128/i64/i128 encoders, which reject unsafe-integer JS numbers
+// at runtime and narrow the input type to plain `bigint`.
+
+import {
+  type FixedSizeEncoder,
+  getI64Encoder as kitI64Encoder,
+  getI128Encoder as kitI128Encoder,
+  getU64Encoder as kitU64Encoder,
+  getU128Encoder as kitU128Encoder,
+} from '@solana/kit';
+
+export * from '@solana/kit';
+
+const U64_MAX = 0xffffffffffffffffn;
+const U128_MAX = 0xffffffffffffffffffffffffffffffffn;
+const I64_MIN = -0x8000000000000000n;
+const I64_MAX = 0x7fffffffffffffffn;
+const I128_MIN = -0x80000000000000000000000000000000n;
+const I128_MAX = 0x7fffffffffffffffffffffffffffffffn;
+
+function coerce(label: string, value: bigint | number, min: bigint, max: bigint): bigint {
+  if (typeof value === 'bigint') {
+    if (value < min || value > max) {
+      throw new RangeError(`${label}: value ${value} out of range [${min}, ${max}]`);
+    }
+    return value;
+  }
+
+  if (typeof value !== 'number') {
+    throw new TypeError(`${label}: expected bigint, got ${typeof value}`);
+  }
+
+  if (!Number.isSafeInteger(value)) {
+    throw new TypeError(
+      `${label}: expected bigint; got number ${value}. ` +
+        'JS numbers above 2^53-1 round silently, pass BigInt(...) instead.',
+    );
+  }
+
+  const bn = BigInt(value);
+  if (bn < min || bn > max) {
+    throw new RangeError(`${label}: value ${bn} out of range [${min}, ${max}]`);
+  }
+  return bn;
+}
+
+function guardEncoder<Size extends number>(
+  label: string,
+  inner: FixedSizeEncoder<bigint | number, Size>,
+  min: bigint,
+  max: bigint,
+): FixedSizeEncoder<bigint, Size> {
+  // Spelled out instead of spreading `inner` so new upstream fields
+  // cause a type error rather than silently skipping the guard.
+  return {
+    fixedSize: inner.fixedSize,
+    write(value, bytes, offset) {
+      return inner.write(coerce(label, value as bigint | number, min, max), bytes, offset);
+    },
+    encode(value) {
+      return inner.encode(coerce(label, value as bigint | number, min, max));
+    },
+  };
+}
+
+export function getU64Encoder(): FixedSizeEncoder<bigint, 8> {
+  return guardEncoder('u64', kitU64Encoder(), 0n, U64_MAX);
+}
+
+export function getU128Encoder(): FixedSizeEncoder<bigint, 16> {
+  return guardEncoder('u128', kitU128Encoder(), 0n, U128_MAX);
+}
+
+export function getI64Encoder(): FixedSizeEncoder<bigint, 8> {
+  return guardEncoder('i64', kitI64Encoder(), I64_MIN, I64_MAX);
+}
+
+export function getI128Encoder(): FixedSizeEncoder<bigint, 16> {
+  return guardEncoder('i128', kitI128Encoder(), I128_MIN, I128_MAX);
+}

package/src/clients/typescript/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/src/clients/typescript/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm'],
+  dts: true,
+  clean: true,
+  sourcemap: true,
+});

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './sdk/utils.js';
+export * from './sdk/client.js';
+export * from './sdk/channel.js';
+export * from './sdk/voucher.js';

package/src/sdk/channel.ts

@@ -0,0 +1,128 @@
+import { SHUNT_TREASURY, devnet, type ShuntClient } from "./client.js";
+import { address, getAddressEncoder, getU64Encoder, getProgramDerivedAddress, type Address } from "@solana/kit";
+import { findAssociatedTokenPda, TOKEN_PROGRAM_ADDRESS, ASSOCIATED_TOKEN_PROGRAM_ADDRESS } from "@solana-program/token";
+import { getOpenInstructionAsync } from '../clients/typescript/src/generated/instructions/open.js';
+import { getTopUpInstruction } from '../clients/typescript/src/generated/instructions/topUp.js';
+// import { getTopUpInstruction } from '../clients/typescript/dist/topUp.js';
+import { sendInstructions } from "./utils.js";
+
+const USDC_MAINNET = address("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+const USDC_DEVNET = address("4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU");
+
+async function findChannelPda(
+  client: ShuntClient,
+  mint: Address,
+  salt: bigint,
+  openSlot: bigint
+): Promise<Address> {
+  const addressEncoder = getAddressEncoder();
+
+  const u64Encoder = getU64Encoder();
+
+  const [pda] = await getProgramDerivedAddress({
+    programAddress: address("CHNLxYvVA28MJP9PrFuDXccuoGXAx7jBacfLEkahyGsX"),
+    seeds: [
+      new TextEncoder().encode("channel"),
+      addressEncoder.encode(client.payer.address),
+      addressEncoder.encode(address(SHUNT_TREASURY)),
+      addressEncoder.encode(mint),
+      addressEncoder.encode(client.payer.address),
+      u64Encoder.encode(salt),
+      u64Encoder.encode(openSlot),
+    ],
+  });
+
+  return pda;
+}
+
+export async function openPaymentChannel(client: ShuntClient, depositAmount: bigint) {
+  const USDC_MINT = devnet ? USDC_DEVNET : USDC_MAINNET;
+  const salt = BigInt(Math.floor(Math.random() * 1_000_000_000));
+  const gracePeriod = 86400;
+
+  const currentSlot = await client.rpc.getSlot().send();
+  const openSlot = BigInt(currentSlot);
+
+  const channelPda = await findChannelPda(
+    client,
+    USDC_MINT,
+    salt,
+    openSlot
+  );
+
+  const [payerTokenAccount] = await findAssociatedTokenPda({
+    owner: client.payer.address,
+    mint: USDC_MINT,
+    tokenProgram: TOKEN_PROGRAM_ADDRESS,
+  });
+
+  const [channelTokenAccount] = await findAssociatedTokenPda({
+    owner: channelPda,
+    mint: USDC_MINT,
+    tokenProgram: TOKEN_PROGRAM_ADDRESS,
+  });
+
+  const openIx = await getOpenInstructionAsync({
+    payer: client.payer,
+    rentPayer: client.payer,
+    payee: address(SHUNT_TREASURY),
+    mint: USDC_MINT,
+    authorizedSigner: client.payer.address,
+    channel: channelPda,
+    payerTokenAccount: payerTokenAccount,
+    channelTokenAccount: channelTokenAccount,
+
+    systemProgram: address("11111111111111111111111111111111"),
+    tokenProgram: TOKEN_PROGRAM_ADDRESS,
+    associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    rent: address("SysvarRent111111111111111111111111111111111"),
+
+    // Arguments
+    openArgs: {
+      salt: salt,
+      deposit: depositAmount,
+      gracePeriod: gracePeriod,
+      openSlot: openSlot,
+      recipients: [],
+    }
+  });
+
+  const signature = await sendInstructions(client, [openIx]);
+
+  return { channel: channelPda, signature };
+}
+
+
+
+export async function topUpPaymentChannel(client: ShuntClient, channelAddress: Address, topUpAmount: bigint) {
+  const USDC_MINT = devnet ? USDC_DEVNET : USDC_MAINNET;
+
+  const [payerTokenAccount] = await findAssociatedTokenPda({
+    owner: client.payer.address,
+    mint: USDC_MINT,
+    tokenProgram: TOKEN_PROGRAM_ADDRESS,
+  });
+
+  // 2. Derive the Channel's Escrow Associated Token Account
+  const [channelTokenAccount] = await findAssociatedTokenPda({
+    owner: channelAddress,
+    mint: USDC_MINT,
+    tokenProgram: TOKEN_PROGRAM_ADDRESS,
+  });
+
+  const topUpIx = getTopUpInstruction({
+    payer: client.payer,
+    channel: channelAddress,
+    payerTokenAccount: payerTokenAccount,
+    channelTokenAccount: channelTokenAccount,
+    mint: USDC_MINT,
+    tokenProgram: TOKEN_PROGRAM_ADDRESS,
+    topUpArgs: {
+      amount: topUpAmount,
+    },
+  });
+
+  const signature = await sendInstructions(client, [topUpIx]);
+
+  return { channel: channelAddress, signature };
+}

package/src/sdk/client.ts

@@ -0,0 +1,22 @@
+import { createClient } from "@solana/kit";
+import { solanaMainnetRpc, solanaDevnetRpc } from '@solana/kit-plugin-rpc';
+import { signerFromFile } from '@solana/kit-plugin-signer';
+import { systemProgram } from '@solana-program/system';
+import { tokenProgram } from '@solana-program/token';
+
+export const devnet = true;
+
+export async function createShuntClient(signerFilePath: string) {
+  const rpc = devnet ? solanaDevnetRpc({ rpcUrl: "https://api.devnet.solana.com" }) : solanaMainnetRpc({ rpcUrl: "https://api.mainnet-beta.solana.com" });
+
+  const client = await createClient()
+    .use(signerFromFile(signerFilePath))
+    .use(rpc)
+    .use(systemProgram())
+    .use(tokenProgram());
+
+  return client;
+}
+
+export type ShuntClient = Awaited<ReturnType<typeof createShuntClient>>;
+export const SHUNT_TREASURY = "4gNrRt7FKoetTTGbJuzp6WYtgqqmKLpjXybPqY3zbVCh";

package/src/sdk/utils.ts

@@ -0,0 +1,29 @@
+import { type ShuntClient } from "./client.js";
+import { pipe, createTransactionMessage, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstructions, signTransactionMessageWithSigners, getSignatureFromTransaction, getBase64EncodedWireTransaction, type Instruction } from "@solana/kit";
+
+export async function sendInstructions(
+  client: ShuntClient,
+  instructions: Instruction[]
+): Promise<string> {
+  const { value: latestBlockhash } = await client.rpc.getLatestBlockhash().send();
+
+  const transactionMessage = pipe(
+    createTransactionMessage({ version: 0 }),
+    (tx) => setTransactionMessageFeePayerSigner(client.payer, tx),
+    (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+    (tx) => appendTransactionMessageInstructions(instructions, tx)
+  );
+
+  const signedTransaction = await signTransactionMessageWithSigners(transactionMessage);
+
+  const transactionSignature = getSignatureFromTransaction(signedTransaction);
+
+  const base64WireTransaction = getBase64EncodedWireTransaction(signedTransaction);
+
+  // 4. Send the base64 string using the RPC client
+  await client.rpc.sendTransaction(base64WireTransaction, {
+      encoding: "base64",
+    }).send();
+
+  return transactionSignature;
+}

package/src/sdk/voucher.ts

@@ -0,0 +1,50 @@
+import { type ShuntClient } from "./client.js";
+import { getAddressEncoder, isMessagePartialSigner, getBase58Decoder, type Address } from "@solana/kit";
+
+export async function createSignedVoucher(client: ShuntClient, channelAddress: Address, cumulativeAmount: bigint, expiresAtUnixTimestamp?: bigint) {
+  if (!client.payer || !isMessagePartialSigner(client.payer)) {
+    throw new Error("The client's payer does not support message signing.");
+  }
+
+  const expiresAt = expiresAtUnixTimestamp ?? 0n;
+
+  const payload = new Uint8Array(50);
+  const dataView = new DataView(payload.buffer);
+
+  // 2. Set Magic Bytes (0x56, 0x01) at offsets 0..2
+  // Magic Bytes (0x56, 0x01) at offset 0
+  payload.set([0x56, 0x01], 0);
+
+  // 3. Set Channel Address at offsets 2..34
+  const addressEncoder = getAddressEncoder();
+  const channelBytes = addressEncoder.encode(channelAddress);
+  payload.set(channelBytes, 2);
+
+  // 4. Set Cumulative Amount at offsets 34..42 (8 bytes, Little-Endian)
+  dataView.setBigUint64(34, cumulativeAmount, true);
+
+  // 5. Set Expires At at offsets 42..50 (8 bytes, Little-Endian)
+  dataView.setBigInt64(42, expiresAt, true);
+
+  const signedMessages = await client.payer.signMessages([{ content: payload, signatures: {} }]);
+  const signatureBytes = signedMessages[0][client.payer.address];
+
+  const base58Decoder = getBase58Decoder();
+
+  // 7. Construct the HTTP Transport Envelope (SignedVoucher)
+  return {
+    voucher: {
+      voucher: {
+        channelId: channelAddress,
+        cumulativeAmount: cumulativeAmount.toString(),
+        // Only include expiresAt in the JSON if it is non-zero
+        ...(expiresAt !== 0n && {
+          expiresAt: new Date(Number(expiresAt) * 1000).toISOString()
+        })
+      },
+      signer: client.payer.address,
+      signature: base58Decoder.decode(signatureBytes),
+      signatureType: "ed25519"
+    }
+  };
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true, // Generates .d.ts files for your users
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"]
+}