@reflectmoney/oracle.ts 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,110 @@
+import { Connection, PublicKey, Transaction, Keypair } from '@solana/web3.js';
+import { Buffer } from 'buffer';
+export declare const DOPPLER_PROGRAM_ID: PublicKey;
+export declare const ADMIN_PUBKEY: PublicKey;
+/**
+ * Generic Oracle data structure
+ */
+export interface Oracle<T> {
+    sequence: bigint;
+    payload: T;
+}
+/**
+ * Serializer interface for custom payload types
+ */
+export interface PayloadSerializer<T> {
+    serialize(payload: T): Buffer;
+    deserialize(buffer: Buffer): T;
+    size(): number;
+}
+/**
+ * Built-in serializer for u64 payloads (price feeds)
+ */
+export declare class U64Serializer implements PayloadSerializer<bigint> {
+    serialize(payload: bigint): Buffer;
+    deserialize(buffer: Buffer): bigint;
+    size(): number;
+}
+/**
+ * Price Feed structure matching the Rust implementation
+ */
+export interface PriceFeed {
+    price: bigint;
+}
+/**
+ * Serializer for PriceFeed payloads
+ */
+export declare class PriceFeedSerializer implements PayloadSerializer<PriceFeed> {
+    serialize(payload: PriceFeed): Buffer;
+    deserialize(buffer: Buffer): PriceFeed;
+    size(): number;
+}
+/**
+ * Transaction builder for Doppler oracle updates
+ */
+export declare class TransactionBuilder {
+    private admin;
+    private oracleUpdateInstructions;
+    private unitPrice?;
+    private computeUnits;
+    private loadedAccountDataSize;
+    constructor(admin: Keypair);
+    /**
+     * Add an oracle update instruction to the transaction
+     */
+    addOracleUpdate<T>(oraclePubkey: PublicKey, oracle: Oracle<T>, serializer: PayloadSerializer<T>): this;
+    /**
+     * Set the compute unit price in micro-lamports
+     */
+    withUnitPrice(microLamports: bigint): this;
+    /**
+     * Build the final transaction
+     */
+    build(recentBlockhash: string): Transaction;
+    private createUpdateInstruction;
+    private serializeOracle;
+}
+/**
+ * Main Doppler class for interacting with oracle accounts
+ */
+export declare class Doppler {
+    private connection;
+    private admin;
+    constructor(connection: Connection, admin: Keypair);
+    /**
+     * Create a new transaction builder
+     */
+    createTransactionBuilder(): TransactionBuilder;
+    /**
+     * Fetch oracle account data and deserialize it
+     */
+    fetchOracle<T>(oraclePubkey: PublicKey, serializer: PayloadSerializer<T>): Promise<Oracle<T> | null>;
+    /**
+     * Deserialize oracle data from a buffer
+     */
+    deserializeOracle<T>(data: Buffer, serializer: PayloadSerializer<T>): Oracle<T>;
+    /**
+     * Create an oracle account with a seed
+     */
+    createOracleAccount<T>(seed: string, serializer: PayloadSerializer<T>, initialOracle: Oracle<T>): Promise<PublicKey>;
+    /**
+     * Update a single oracle account
+     */
+    updateOracle<T>(oraclePubkey: PublicKey, oracle: Oracle<T>, serializer: PayloadSerializer<T>, unitPrice?: bigint): Promise<string>;
+    /**
+     * Update multiple oracle accounts in a single transaction
+     */
+    updateMultipleOracles<T>(updates: Array<{
+        oraclePubkey: PublicKey;
+        oracle: Oracle<T>;
+        serializer: PayloadSerializer<T>;
+    }>, unitPrice?: bigint): Promise<string>;
+    /**
+     * Get the admin keypair
+     */
+    getAdmin(): Keypair;
+    /**
+     * Get the connection
+     */
+    getConnection(): Connection;
+}

package/dist/index.js

@@ -0,0 +1,283 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Doppler = exports.TransactionBuilder = exports.PriceFeedSerializer = exports.U64Serializer = exports.ADMIN_PUBKEY = exports.DOPPLER_PROGRAM_ID = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const buffer_1 = require("buffer");
+const compute_budget_1 = require("@solana-program/compute-budget");
+// Program ID: PRicevBH6BaeaE8qmrxrwGBZ5hSZ9vjBNue5Ygot1ML
+exports.DOPPLER_PROGRAM_ID = new web3_js_1.PublicKey('PRicevBH6BaeaE8qmrxrwGBZ5hSZ9vjBNue5Ygot1ML');
+// Admin public key: pRiCEzwgkSi7KTsQHdyfuRbPEuCFoK9sA5QVn2hvABV
+exports.ADMIN_PUBKEY = new web3_js_1.PublicKey('pRiCEzwgkSi7KTsQHdyfuRbPEuCFoK9sA5QVn2hvABV');
+// Constants for compute unit calculations
+const SEQUENCE_CHECK_CU = 5;
+const ADMIN_VERIFICATION_CU = 6;
+const PAYLOAD_WRITE_CU = 6;
+const COMPUTE_BUDGET_IX_CU = 150;
+const COMPUTE_BUDGET_UNIT_PRICE_SIZE = 9;
+const COMPUTE_BUDGET_UNIT_LIMIT_SIZE = 5;
+const COMPUTE_BUDGET_DATA_LIMIT_SIZE = 5;
+const COMPUTE_BUDGET_PROGRAM_SIZE = 22;
+const ORACLE_PROGRAM_SIZE = 36;
+/**
+ * Built-in serializer for u64 payloads (price feeds)
+ */
+class U64Serializer {
+    serialize(payload) {
+        const buf = buffer_1.Buffer.alloc(8);
+        buf.writeBigUInt64LE(payload);
+        return buf;
+    }
+    deserialize(buffer) {
+        return buffer.readBigUInt64LE(0);
+    }
+    size() {
+        return 8;
+    }
+}
+exports.U64Serializer = U64Serializer;
+/**
+ * Serializer for PriceFeed payloads
+ */
+class PriceFeedSerializer {
+    serialize(payload) {
+        const buf = buffer_1.Buffer.alloc(8);
+        buf.writeBigUInt64LE(payload.price);
+        return buf;
+    }
+    deserialize(buffer) {
+        return {
+            price: buffer.readBigUInt64LE(0),
+        };
+    }
+    size() {
+        return 8;
+    }
+}
+exports.PriceFeedSerializer = PriceFeedSerializer;
+/**
+ * Transaction builder for Doppler oracle updates
+ */
+class TransactionBuilder {
+    constructor(admin) {
+        this.admin = admin;
+        this.oracleUpdateInstructions = [];
+        this.computeUnits = COMPUTE_BUDGET_IX_CU * 2;
+        this.loadedAccountDataSize = ORACLE_PROGRAM_SIZE +
+            COMPUTE_BUDGET_PROGRAM_SIZE +
+            COMPUTE_BUDGET_UNIT_LIMIT_SIZE +
+            COMPUTE_BUDGET_DATA_LIMIT_SIZE +
+            2;
+    }
+    /**
+     * Add an oracle update instruction to the transaction
+     */
+    addOracleUpdate(oraclePubkey, oracle, serializer) {
+        const instruction = this.createUpdateInstruction(oraclePubkey, oracle, serializer);
+        const payloadSize = serializer.size();
+        const oracleSize = 8 + payloadSize; // sequence + payload
+        this.computeUnits +=
+            SEQUENCE_CHECK_CU +
+                ADMIN_VERIFICATION_CU +
+                PAYLOAD_WRITE_CU +
+                Math.floor(oracleSize / 4);
+        this.loadedAccountDataSize += oracleSize * 2;
+        this.oracleUpdateInstructions.push(instruction);
+        return this;
+    }
+    /**
+     * Set the compute unit price in micro-lamports
+     */
+    withUnitPrice(microLamports) {
+        this.unitPrice = microLamports;
+        return this;
+    }
+    /**
+     * Build the final transaction
+     */
+    build(recentBlockhash) {
+        const instructions = [];
+        let loadedAccountDataSize = this.loadedAccountDataSize;
+        let computeUnits = this.computeUnits;
+        if (this.unitPrice !== undefined) {
+            instructions.push(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
+                microLamports: this.unitPrice,
+            }));
+            loadedAccountDataSize += COMPUTE_BUDGET_UNIT_PRICE_SIZE;
+            computeUnits += COMPUTE_BUDGET_IX_CU;
+        }
+        const loadedAccountsDataSizeLimitInstruction = (0, compute_budget_1.getSetLoadedAccountsDataSizeLimitInstruction)({
+            accountDataSizeLimit: loadedAccountDataSize * 2
+        });
+        instructions.push(new web3_js_1.TransactionInstruction({
+            keys: [],
+            programId: new web3_js_1.PublicKey(loadedAccountsDataSizeLimitInstruction.programAddress.toString()),
+            data: buffer_1.Buffer.from(loadedAccountsDataSizeLimitInstruction.data),
+        }));
+        instructions.push(web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
+            units: computeUnits,
+        }));
+        instructions.push(...this.oracleUpdateInstructions);
+        const transaction = new web3_js_1.Transaction({
+            feePayer: this.admin.publicKey,
+            recentBlockhash,
+        });
+        transaction.add(...instructions);
+        transaction.sign(this.admin);
+        return transaction;
+    }
+    createUpdateInstruction(oraclePubkey, oracle, serializer) {
+        const data = this.serializeOracle(oracle, serializer);
+        return new web3_js_1.TransactionInstruction({
+            programId: exports.DOPPLER_PROGRAM_ID,
+            keys: [
+                {
+                    pubkey: this.admin.publicKey,
+                    isSigner: true,
+                    isWritable: false,
+                },
+                {
+                    pubkey: oraclePubkey,
+                    isSigner: false,
+                    isWritable: true,
+                },
+            ],
+            data,
+        });
+    }
+    serializeOracle(oracle, serializer) {
+        const sequenceBuffer = buffer_1.Buffer.alloc(8);
+        sequenceBuffer.writeBigUInt64LE(oracle.sequence);
+        const payloadBuffer = serializer.serialize(oracle.payload);
+        return buffer_1.Buffer.concat([sequenceBuffer, payloadBuffer]);
+    }
+}
+exports.TransactionBuilder = TransactionBuilder;
+/**
+ * Main Doppler class for interacting with oracle accounts
+ */
+class Doppler {
+    constructor(connection, admin) {
+        this.connection = connection;
+        this.admin = admin;
+    }
+    /**
+     * Create a new transaction builder
+     */
+    createTransactionBuilder() {
+        return new TransactionBuilder(this.admin);
+    }
+    /**
+     * Fetch oracle account data and deserialize it
+     */
+    fetchOracle(oraclePubkey, serializer) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const accountInfo = yield this.connection.getAccountInfo(oraclePubkey);
+                if (!accountInfo || !accountInfo.data) {
+                    return null;
+                }
+                return this.deserializeOracle(accountInfo.data, serializer);
+            }
+            catch (error) {
+                console.error('Error fetching oracle account:', error);
+                return null;
+            }
+        });
+    }
+    /**
+     * Deserialize oracle data from a buffer
+     */
+    deserializeOracle(data, serializer) {
+        const expectedSize = 8 + serializer.size();
+        if (data.length < expectedSize) {
+            throw new Error(`Invalid oracle data size. Expected at least ${expectedSize}, got ${data.length}`);
+        }
+        const sequence = data.readBigUInt64LE(0);
+        const payloadBuffer = data.subarray(8, 8 + serializer.size());
+        const payload = serializer.deserialize(payloadBuffer);
+        return { sequence, payload };
+    }
+    /**
+     * Create an oracle account with a seed
+     */
+    createOracleAccount(seed, serializer, initialOracle) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const oracleSize = 8 + serializer.size();
+            const lamports = yield this.connection.getMinimumBalanceForRentExemption(oracleSize);
+            const oraclePubkey = yield web3_js_1.PublicKey.createWithSeed(this.admin.publicKey, seed, exports.DOPPLER_PROGRAM_ID);
+            const createAccountInstruction = web3_js_1.SystemProgram.createAccountWithSeed({
+                fromPubkey: this.admin.publicKey,
+                newAccountPubkey: oraclePubkey,
+                basePubkey: this.admin.publicKey,
+                seed,
+                lamports,
+                space: oracleSize,
+                programId: exports.DOPPLER_PROGRAM_ID,
+            });
+            const recentBlockhash = yield this.connection.getLatestBlockhash();
+            const transaction = new web3_js_1.Transaction({
+                feePayer: this.admin.publicKey,
+                recentBlockhash: recentBlockhash.blockhash,
+            });
+            transaction.add(createAccountInstruction);
+            transaction.sign(this.admin);
+            yield (0, web3_js_1.sendAndConfirmTransaction)(this.connection, transaction, [this.admin]);
+            return oraclePubkey;
+        });
+    }
+    /**
+     * Update a single oracle account
+     */
+    updateOracle(oraclePubkey, oracle, serializer, unitPrice) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const recentBlockhash = yield this.connection.getLatestBlockhash();
+            let builder = this.createTransactionBuilder().addOracleUpdate(oraclePubkey, oracle, serializer);
+            if (unitPrice !== undefined) {
+                builder = builder.withUnitPrice(unitPrice);
+            }
+            const transaction = builder.build(recentBlockhash.blockhash);
+            const signature = yield (0, web3_js_1.sendAndConfirmTransaction)(this.connection, transaction, [this.admin]);
+            return signature;
+        });
+    }
+    /**
+     * Update multiple oracle accounts in a single transaction
+     */
+    updateMultipleOracles(updates, unitPrice) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const recentBlockhash = yield this.connection.getLatestBlockhash();
+            let builder = this.createTransactionBuilder();
+            for (const update of updates) {
+                builder = builder.addOracleUpdate(update.oraclePubkey, update.oracle, update.serializer);
+            }
+            if (unitPrice !== undefined) {
+                builder = builder.withUnitPrice(unitPrice);
+            }
+            const transaction = builder.build(recentBlockhash.blockhash);
+            const signature = yield (0, web3_js_1.sendAndConfirmTransaction)(this.connection, transaction, [this.admin]);
+            return signature;
+        });
+    }
+    /**
+     * Get the admin keypair
+     */
+    getAdmin() {
+        return this.admin;
+    }
+    /**
+     * Get the connection
+     */
+    getConnection() {
+        return this.connection;
+    }
+}
+exports.Doppler = Doppler;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@reflectmoney/oracle.ts",
+  "version": "1.0.0",
+  "type": "commonjs",
+  "author": "L0STE, stablecoinjesus @ Palindrome Engineering",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/palindrome-eng/doppler.git"
+  },
+  "dependencies": {
+    "@solana-program/compute-budget": "^0.9.0",
+    "@solana-program/token": "^0.6.0",
+    "@solana/buffer-layout": "^4.0.1",
+    "@solana/kit": "^3.0.3",
+    "@solana/web3.js": "^1.98.4",
+    "bn.js": "^5.2.2",
+    "buffer": "^6.0.3"
+  },
+  "devDependencies": {
+    "@types/bn.js": "5.1.6",
+    "@types/chai": "^4.3.11",
+    "@types/mocha": "^10.0.6",
+    "bs58": "^6.0.0",
+    "chai": "^4.3.10",
+    "mocha": "^10.2.0",
+    "ts-node": "^10.9.2"
+  },
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "/dist"
+  ]
+}