@mnee/ts-sdk 1.0.0

package/dist/mnee.types.d.ts

@@ -0,0 +1,251 @@
+export type Environment = 'production' | 'sandbox';
+export type SdkConfig = {
+    environment: Environment;
+    apiKey?: string;
+};
+export type MNEEFee = {
+    min: number;
+    max: number;
+    fee: number;
+};
+export type MNEEConfig = {
+    approver: string;
+    feeAddress: string;
+    burnAddress: string;
+    mintAddress: string;
+    fees: MNEEFee[];
+    decimals: number;
+    tokenId: string;
+};
+export type TxOperation = 'transfer' | 'burn' | 'deploy' | 'mint' | 'redeem';
+export type MNEEUtxo = {
+    data: {
+        bsv21: {
+            amt: number;
+            dec: number;
+            icon: string;
+            id: string;
+            op: string;
+            sym: string;
+        };
+        cosign: {
+            address: string;
+            cosigner: string;
+        };
+    };
+    height: number;
+    idx: number;
+    outpoint: string;
+    owners: string[];
+    satoshis: number;
+    score: number;
+    script: string;
+    txid: string;
+    vout: number;
+};
+export type SignatureRequest = {
+    prevTxid: string;
+    outputIndex: number;
+    inputIndex: number;
+    satoshis: number;
+    address: string | string[];
+    script?: string;
+    sigHashType?: number;
+    csIdx?: number;
+    data?: unknown;
+};
+export type TransactionFormat = 'tx' | 'beef' | 'ef';
+export type MNEEBalance = {
+    address: string;
+    amount: number;
+    decimalAmount: number;
+};
+export type SendMNEE = {
+    address: string;
+    amount: number;
+};
+export type GetSignatures = {
+    rawtx: string;
+    sigRequests: SignatureRequest[];
+    format?: TransactionFormat;
+};
+export type SignatureResponse = {
+    inputIndex: number;
+    sig: string;
+    pubKey: string;
+    sigHashType: number;
+    csIdx?: number;
+};
+export type MneeInscription = {
+    p: string;
+    op: string;
+    id: string;
+    amt: string;
+    metadata?: {
+        action?: 'mint' | 'redeem';
+        [key: string]: any;
+    };
+};
+export type ParsedCosigner = {
+    cosigner: string;
+    address: string;
+};
+export interface File {
+    hash: string;
+    size: number;
+    type: string;
+    content: number[];
+}
+export interface Inscription {
+    file?: File;
+    fields?: {
+        [key: string]: any;
+    };
+    parent?: string;
+}
+export type BalanceResponse = Array<{
+    address: string;
+    amt: number;
+    precised: number;
+}>;
+export type TransferResponse = {
+    ticketId?: string;
+    rawtx?: string;
+};
+export type TransferStatus = {
+    id: string;
+    tx_id: string;
+    tx_hex: string;
+    action_requested: 'transfer';
+    status: 'BROADCASTING' | 'SUCCESS' | 'MINED' | 'FAILED';
+    createdAt: string;
+    updatedAt: string;
+    errors: string | null;
+};
+export type TransferOptions = {
+    broadcast?: boolean;
+    callbackUrl?: string;
+};
+export type TransferWebhookResponse = {
+    id: string;
+    tx_id: string;
+    tx_hex: string;
+    action_requested: 'transfer';
+    callback_url: string;
+    status: 'SUCCESS' | 'BROADCASTING' | 'MINED' | 'FAILED';
+    createdAt: string;
+    updatedAt: string;
+    errors: string | null;
+};
+export interface TransferMultiOptions {
+    inputs: Array<{
+        txid: string;
+        vout: number;
+        wif: string;
+    }>;
+    recipients: SendMNEE[];
+    changeAddress?: string | Array<{
+        address: string;
+        amount: number;
+    }>;
+}
+export type MneeSync = {
+    txid: string;
+    outs: null;
+    height: number;
+    idx: number;
+    score: number;
+    rawtx: string;
+    senders: string[];
+    receivers: string[];
+};
+export type Counterparty = {
+    address: string;
+    amount: number;
+};
+export type TxStatus = 'confirmed' | 'unconfirmed';
+export type TxType = 'send' | 'receive';
+export type TxHistory = {
+    txid: string;
+    height: number;
+    status: TxStatus;
+    type: TxType;
+    amount: number;
+    counterparties: Counterparty[];
+    fee: number;
+    score: number;
+};
+export type TxHistoryResponse = {
+    address: string;
+    history: TxHistory[];
+    nextScore: number;
+};
+export type TxAddressAmount = {
+    address: string;
+    amount: number;
+};
+export type ParseTxResponse = {
+    txid: string;
+    environment: Environment;
+    type: TxOperation;
+    inputs: TxAddressAmount[];
+    outputs: TxAddressAmount[];
+    isValid: boolean;
+    inputTotal: string;
+    outputTotal: string;
+};
+export interface ParseOptions {
+    includeRaw?: boolean;
+}
+export interface ParseTxExtendedResponse extends ParseTxResponse {
+    raw?: {
+        txHex: string;
+        inputs: Array<{
+            txid: string;
+            vout: number;
+            scriptSig: string;
+            sequence: number;
+            satoshis: number;
+            address?: string;
+            tokenData?: any;
+        }>;
+        outputs: Array<{
+            value: number;
+            scriptPubKey: string;
+            address?: string;
+            tokenData?: any;
+        }>;
+    };
+}
+export interface AddressHistoryParams {
+    address: string;
+    fromScore?: number;
+    limit?: number;
+    order?: 'asc' | 'desc';
+}
+export interface ProcessedInput {
+    address?: string;
+    amount: number;
+    satoshis: number;
+    inscription?: MneeInscription | null;
+    cosigner?: ParsedCosigner;
+}
+export interface ProcessedOutput {
+    address?: string;
+    amount: number;
+    satoshis: number;
+    inscription?: MneeInscription | null;
+    cosigner?: ParsedCosigner;
+}
+export interface TxInputResponse {
+    inputs: ProcessedInput[];
+    total: bigint;
+    environment?: Environment;
+    type?: TxOperation;
+}
+export interface TxOutputResponse {
+    outputs: ProcessedOutput[];
+    total: bigint;
+    environment?: Environment;
+    type?: TxOperation;
+}

package/dist/mneeCosignTemplate.d.ts

@@ -0,0 +1,54 @@
+import { LockingScript, type PrivateKey, type PublicKey, type Script, type ScriptTemplate, type Transaction, UnlockingScript } from "@bsv/sdk";
+/**
+ * P2PKH (Pay To Public Key Hash) class implementing ScriptTemplate.
+ *
+ * This class provides methods to create Pay To Public Key Hash locking and unlocking scripts, including the unlocking of P2PKH UTXOs with the private key.
+ */
+export default class CosignTemplate implements ScriptTemplate {
+    /**
+     * Creates a P2PKH locking script for a given public key hash or address string
+     *
+     * @param {number[] | string} userPKHash or address - An array or address representing the public key hash of the owning user.
+     * @param {PublicKey} approverPubKey - Public key of the approver.
+     * @returns {LockingScript} - A P2PKH locking script.
+     */
+    lock(userPKHash: string | number[], approverPubKey: PublicKey): LockingScript;
+    /**
+     * Creates a function that generates a P2PKH unlocking script along with its signature and length estimation.
+     *
+     * The returned object contains:
+     * 1. `sign` - A function that, when invoked with a transaction and an input index,
+     *    produces an unlocking script suitable for a P2PKH locked output.
+     * 2. `estimateLength` - A function that returns the estimated length of the unlocking script in bytes.
+     *
+     * @param {PrivateKey} userPrivateKey - The private key used for signing the transaction.
+     * @param {'all'|'none'|'single'} signOutputs - The signature scope for outputs.
+     * @param {boolean} anyoneCanPay - Flag indicating if the signature allows for other inputs to be added later.
+     * @param {number} sourceSatoshis - Optional. The amount being unlocked. Otherwise the input.sourceTransaction is required.
+     * @param {Script} lockingScript - Optional. The lockinScript. Otherwise the input.sourceTransaction is required.
+     * @returns {Object} - An object containing the `sign` and `estimateLength` functions.
+     */
+    userUnlock(userPrivateKey: PrivateKey, signOutputs?: "all" | "none" | "single", anyoneCanPay?: boolean, sourceSatoshis?: number, lockingScript?: Script): {
+        sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>;
+        estimateLength: () => Promise<182>;
+    };
+    /**
+     * Creates a function that generates a P2PKH unlocking script along with its signature and length estimation.
+     *
+     * The returned object contains:
+     * 1. `sign` - A function that, when invoked with a transaction and an input index,
+     *    produces an unlocking script suitable for a P2PKH locked output.
+     * 2. `estimateLength` - A function that returns the estimated length of the unlocking script in bytes.
+     *
+     * @param {PrivateKey} approverPrivateKey - The private key used for signing the transaction.
+     * @param {'all'|'none'|'single'} signOutputs - The signature scope for outputs.
+     * @param {boolean} anyoneCanPay - Flag indicating if the signature allows for other inputs to be added later.
+     * @param {number} sourceSatoshis - Optional. The amount being unlocked. Otherwise the input.sourceTransaction is required.
+     * @param {Script} lockingScript - Optional. The lockinScript. Otherwise the input.sourceTransaction is required.
+     * @returns {Object} - An object containing the `sign` and `estimateLength` functions.
+     */
+    unlock(approverPrivateKey: PrivateKey, userSigScript: Script, signOutputs?: "all" | "none" | "single", anyoneCanPay?: boolean, sourceSatoshis?: number, lockingScript?: Script): {
+        sign: (tx: Transaction, inputIndex: number) => Promise<UnlockingScript>;
+        estimateLength: () => Promise<182>;
+    };
+}

package/dist/mneeService.d.ts

@@ -0,0 +1,51 @@
+import { Script } from '@bsv/sdk';
+import { MNEEBalance, MNEEConfig, SdkConfig, MNEEUtxo, ParseTxResponse, ParseTxExtendedResponse, ParseOptions, SendMNEE, TransferMultiOptions, TxHistoryResponse, AddressHistoryParams, TransferResponse, TransferStatus, TransferOptions } from './mnee.types.js';
+export declare class MNEEService {
+    private mneeApiKey;
+    private mneeConfig;
+    private mneeApi;
+    constructor(config: SdkConfig);
+    getCosignerConfig(): Promise<MNEEConfig>;
+    toAtomicAmount(amount: number): number;
+    fromAtomicAmount(amount: number): number;
+    private createInscription;
+    getUtxos(address: string | string[], page?: number, size?: number, order?: 'asc' | 'desc'): Promise<MNEEUtxo[]>;
+    private fetchRawTx;
+    private getSignatures;
+    getEnoughUtxos(address: string, totalAtomicTokenAmount: number): Promise<MNEEUtxo[]>;
+    getAllUtxos(address: string): Promise<MNEEUtxo[]>;
+    transfer(request: SendMNEE[], wif: string, transferOptions?: TransferOptions): Promise<TransferResponse>;
+    submitRawTx(rawtx: string, transferOptions?: TransferOptions): Promise<TransferResponse>;
+    getTxStatus(ticketId: string): Promise<TransferStatus>;
+    getBalance(address: string): Promise<MNEEBalance>;
+    getBalances(addresses: string[]): Promise<MNEEBalance[]>;
+    private processMneeValidation;
+    validateMneeTx(rawTx: string, request?: SendMNEE[]): Promise<boolean>;
+    private getMneeSyncs;
+    getRecentTxHistory(address: string, fromScore?: number, limit?: number, order?: 'asc' | 'desc'): Promise<TxHistoryResponse>;
+    getRecentTxHistories(params: AddressHistoryParams[]): Promise<TxHistoryResponse[]>;
+    /**
+     * Parses inscription data from a script
+     * @param script The script to parse
+     * @returns The parsed inscription data or null if invalid
+     */
+    private parseInscriptionData;
+    private determineEnvironment;
+    private determineTransactionType;
+    private processTransactionInputs;
+    private processTransactionOutputs;
+    private validateTransaction;
+    private buildParseResponse;
+    private parseTransaction;
+    parseTx(txid: string, options?: ParseOptions): Promise<ParseTxResponse | ParseTxExtendedResponse>;
+    parseTxFromRawTx(rawTxHex: string, options?: ParseOptions): Promise<ParseTxResponse | ParseTxExtendedResponse>;
+    parseInscription(script: Script): import("./mnee.types.js").Inscription | undefined;
+    parseCosignerScripts(scripts: Script[]): import("./mnee.types.js").ParsedCosigner[];
+    private validateUniqueInputs;
+    private addInputsToTransaction;
+    private calculateTransferMultiFee;
+    private addChangeOutputs;
+    private signAllInputs;
+    private validateTokenConservation;
+    transferMulti(options: TransferMultiOptions, transferOptions?: TransferOptions): Promise<TransferResponse>;
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@mnee/ts-sdk",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.0.0",
+  "description": "Official typescript SDK of MNEE USD stablecoin",
+  "type": "module",
+  "source": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.modern.js"
+      },
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.modern.js"
+      }
+    }
+  },
+  "module": "./dist/index.module.js",
+  "unpkg": "./dist/index.umd.js",
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && microbundle --globals @bsv/sdk=bsv && npm pack",
+    "start": "node dist/index.modern.js",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mnee",
+    "bsv",
+    "blockchain",
+    "stablecoin",
+    "1satordinal"
+  ],
+  "author": "MNEE",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mnee-xyz/mnee.git"
+  },
+  "homepage": "https://docs.mnee.io",
+  "bugs": {
+    "url": "https://github.com/mnee-xyz/mnee/issues"
+  },
+  "devDependencies": {
+    "@types/node": "^22.14.0",
+    "microbundle": "^0.15.1",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.19.3",
+    "typescript": "^5.4.5"
+  },
+  "dependencies": {
+    "@bsv/sdk": "^1.3.30",
+    "bip39": "^3.1.0"
+  }
+}