alkanesjs 1.2.0 → 1.2.2

package/dist/index.d.ts

@@ -137,6 +137,25 @@ interface RpcCall<T> {
 }
 declare function buildRpcCall<T, E = unknown>(method: string, params: unknown[] | undefined, url: string): RpcCall<T>;
 
+declare class WaitPacer {
+    private maxPerInterval;
+    private intervalMs;
+    private minGapMs;
+    private starts;
+    private lastStart;
+    private tail;
+    constructor(opts: {
+        maxPerInterval: number;
+        intervalMs: number;
+    });
+    setRate(maxPerInterval: number, intervalMs: number): void;
+    private now;
+    private sleep;
+    private pruneWindow;
+    /** Await this immediately before the call that could rate-limit */
+    waitForPacer(): Promise<void>;
+}
+
 interface ProviderConfig {
     sandshrewUrl: string;
     electrumApiUrl: string;
@@ -144,10 +163,15 @@ interface ProviderConfig {
     explorerUrl: string;
     defaultFeeRate?: number;
     btcTicker?: string;
+    pacerSettings?: PacerSettings;
 }
 declare enum AlkanesPollError {
     UnknownError = "UnknownError"
 }
+type PacerSettings = {
+    intervalMs: number;
+    maxPerInterval: number;
+};
 type AlkanesParsedTraceResult = {
     create?: AlkanesTraceCreateEvent["data"];
     invoke?: AlkanesTraceInvokeEvent["data"];
@@ -158,11 +182,14 @@ declare class Provider {
     readonly electrumApiUrl: string;
     readonly network: Network;
     readonly explorerUrl: string;
+    readonly pacerSettings: PacerSettings;
     readonly btcTicker: string;
+    readonly jitterMs = 1000;
     readonly rpc: BaseRpcProvider;
     readonly defaultFeeRate: number;
     private readonly TIMEOUT_MS;
     private readonly INTERVAL_MS;
+    pacer: WaitPacer;
     constructor(config: ProviderConfig);
     protected txUrl(txid: string): string;
     protected addressUrl(address: string): string;
@@ -186,6 +213,9 @@ declare class ElectrumApiProvider {
     esplora_broadcastTx(rawTransactionHex: string, customElectrumUrl?: string): Promise<BoxedResponse<string, EsploraFetchError>>;
     esplora_getaddresstxs(address: string, lastSeenTransactionId?: string): Promise<BoxedResponse<IEsploraTransaction[], EsploraFetchError>>;
     esplora_getbulktransactions(transactionIds: string[]): Promise<BoxedResponse<IEsploraTransaction[], EsploraFetchError>>;
+    esplora_getblocktiphash(): Promise<BoxedResponse<string, EsploraFetchError>>;
+    _esplora_getrawblock(blockHash: string): Promise<BoxedResponse<string, EsploraFetchError>>;
+    esplora_getrawblocktip(): Promise<BoxedResponse<string, EsploraFetchError>>;
     esplora_gettransaction(transactionId: string): Promise<BoxedResponse<IEsploraTransaction, EsploraFetchError>>;
     esplora_getrawtransaction(transactionId: string): Promise<BoxedResponse<string, EsploraFetchError>>;
     esplora_getspendableinputs(utxoList: EsploraUtxo[]): Promise<BoxedResponse<IEsploraSpendableUtxo[], EsploraFetchError>>;
@@ -585,6 +615,10 @@ declare class BaseRpcProvider {
 }
 
 declare const stripHex: (s: string) => string;
+declare function toU64LittleEndianHex(numStr: string): string;
+declare function makeFakeBlock(height: number | bigint): string;
+declare function toU64BigEndianHex(numStr: string): string;
+declare function toU128LittleEndianHex(numStr: string): string;
 declare function mapToPrimitives(v: any): any;
 declare function unmapFromPrimitives(v: any): any;
 declare function parseSimulateReturn(v: string): AlkanesParsedSimulationResult | undefined;
@@ -1478,5 +1512,5 @@ declare const TokenContract_base: new (provider: Provider, alkaneId: AlkaneId, s
 declare class TokenContract extends TokenContract_base {
 }
 
-export { AddressType, AlkanesBaseContract, AlkanesExecuteError, AlkanesFetchError, AlkanesInscription, AlkanesRpcProvider, AlkanesSimulationError, AlkanesTraceError, BaseRpcProvider, DecodableAlkanesResponse, DecodeError, EcPair, ElectrumApiProvider, Encodable, EncodeError, EsploraFetchError, OrdFetchError, OrdRpcProvider, ParsableAlkaneId, ProtostoneTransaction, ProtostoneTransactionWithInscription, Provider, RpcError, RunesFetchError, RunesRpcProvider, SandshrewFetchError, SandshrewRpcProvider, TokenABI, TokenContract, abi, addInputDynamic, addressFormats, addressNameToType, addressTypeToName, assertHex, buildRpcCall, calculateTaprootTxSize, decodeAlkanesTrace, decodeCBOR, excludeFields, execute, extractAbiErrorMessage, extractWithDummySigs, formatInputsToSign, getAddressType, getDummyProtostoneTransaction, getEstimatedFee, getProtostoneTransactionsWithInscription, getProtostoneUnsignedPsbtBase64, getVSize, hexToUint8Array, mapToPrimitives, minimumFee, parseSimulateReturn, psbtBuilder, redeemTypeFromOutput, reverseHexBytes, schemaAlkaneId, simulate, sleep, stripHex, tapTweakHash, toEsploraTx, toFormattedUtxo, trimUndefined, tweakSigner, u128Schema, unmapFromPrimitives, witnessStackToScriptWitness };
+export { AddressType, AlkanesBaseContract, AlkanesExecuteError, AlkanesFetchError, AlkanesInscription, AlkanesRpcProvider, AlkanesSimulationError, AlkanesTraceError, BaseRpcProvider, DecodableAlkanesResponse, DecodeError, EcPair, ElectrumApiProvider, Encodable, EncodeError, EsploraFetchError, OrdFetchError, OrdRpcProvider, ParsableAlkaneId, ProtostoneTransaction, ProtostoneTransactionWithInscription, Provider, RpcError, RunesFetchError, RunesRpcProvider, SandshrewFetchError, SandshrewRpcProvider, TokenABI, TokenContract, abi, addInputDynamic, addressFormats, addressNameToType, addressTypeToName, assertHex, buildRpcCall, calculateTaprootTxSize, decodeAlkanesTrace, decodeCBOR, excludeFields, execute, extractAbiErrorMessage, extractWithDummySigs, formatInputsToSign, getAddressType, getDummyProtostoneTransaction, getEstimatedFee, getProtostoneTransactionsWithInscription, getProtostoneUnsignedPsbtBase64, getVSize, hexToUint8Array, makeFakeBlock, mapToPrimitives, minimumFee, parseSimulateReturn, psbtBuilder, redeemTypeFromOutput, reverseHexBytes, schemaAlkaneId, simulate, sleep, stripHex, tapTweakHash, toEsploraTx, toFormattedUtxo, toU128LittleEndianHex, toU64BigEndianHex, toU64LittleEndianHex, trimUndefined, tweakSigner, u128Schema, unmapFromPrimitives, witnessStackToScriptWitness };
 export type { Account, AddressKey, Alkane, AlkaneDetails, AlkaneEncoded, AlkaneEncodedSimulationRequest, AlkaneId, AlkaneReadableId, AlkaneRune, AlkaneSimulateRequest, AlkaneToken, AlkanesByAddressOutpoint, AlkanesByAddressResponse, AlkanesByAddressRuneBalance, AlkanesExecuteResponse, AlkanesOutpoint, AlkanesOutpointExtended, AlkanesOutpoints, AlkanesOutpointsExtended, AlkanesParsedSimulationResult, AlkanesParsedTraceResult, AlkanesPushExecuteResponse, AlkanesRawSimulationResponse, AlkanesSimulationResult, AlkanesTraceCreateEvent, AlkanesTraceEncodedCreateEvent, AlkanesTraceEncodedEvent, AlkanesTraceEncodedInvokeEvent, AlkanesTraceEncodedResult, AlkanesTraceEncodedReturnEvent, AlkanesTraceEvent, AlkanesTraceInvokeEvent, AlkanesTraceResult, AlkanesTraceReturnEvent, AlkanesUtxo, AlkanesUtxoBalance, AlkanesUtxoEntry, AvailableDecodeKind, AvailableEncodeKind, CustomSpec, Dec, DecodedCBOR, DecodedCBORValue, DecoderFns, Enc, EncodedAlkaneId, EncoderFns, EsploraAddressResponse, EsploraAddressStats, EsploraUtxo, ExecuteSpec, Expand, FormattedUtxo, HDPaths, IDecodableAlkanesResponse, IEncodable, IEsploraBlockHeader, IEsploraPrevout, IEsploraSpendableUtxo, IEsploraTransaction, IEsploraTransactionStatus, IEsploraVin, IEsploraVout, ISchemaAlkaneId, OpcodeTable, OrdBlock, OrdInscription, OrdOutput, OrdOutputRune, OrdPaginatedIds, OrdSat, ProtoRunesToken, ProtostoneTransactionOptions, ProtostoneTransactionOptionsPartial, ProviderConfig, PsbtInputExtended, ResolveSchema, RpcCall, RpcResponse, RpcTuple, Rune, RuneBalance, RuneName, RunesAddressResult, RunesOutpoint, RunesOutpointResult, Schema, SingularAlkanesTransfer, SingularBTCTransfer, SingularTransfer, SpendStrategy, ViewSpec, WalletStandard };

package/dist/index.js

@@ -34791,6 +34791,7 @@ __export(src_exports, {
   getProtostoneUnsignedPsbtBase64: () => getProtostoneUnsignedPsbtBase64,
   getVSize: () => getVSize,
   hexToUint8Array: () => hexToUint8Array,
+  makeFakeBlock: () => makeFakeBlock,
   mapToPrimitives: () => mapToPrimitives,
   minimumFee: () => minimumFee,
   parseSimulateReturn: () => parseSimulateReturn,
@@ -34804,6 +34805,9 @@ __export(src_exports, {
   tapTweakHash: () => tapTweakHash,
   toEsploraTx: () => toEsploraTx,
   toFormattedUtxo: () => toFormattedUtxo,
+  toU128LittleEndianHex: () => toU128LittleEndianHex,
+  toU64BigEndianHex: () => toU64BigEndianHex,
+  toU64LittleEndianHex: () => toU64LittleEndianHex,
   trimUndefined: () => trimUndefined,
   tweakSigner: () => tweakSigner,
   u128Schema: () => u128Schema,
@@ -37299,7 +37303,8 @@ var ProtostoneTransaction = class {
     this.fee = Math.max(baseFee, this.MINIMUM_FEE);
   }
   calcCumulativeSpendRequirements() {
-    this.cumulativeSpendRequirementBtc = this.fee + this.MINIMUM_PROTOCOL_DUST * 2;
+    this.cumulativeSpendRequirementBtc = this.fee + this.MINIMUM_PROTOCOL_DUST * (this.transactionOptions.transfers?.length ?? 0) + this.MINIMUM_PROTOCOL_DUST;
+    console.log(this.cumulativeSpendRequirementBtc);
     this.cumulativeSpendRequirementAlkanes = this.transactionOptions.transfers.reduce(
       (acc, transfer) => {
         if (isBTCTransfer(transfer)) {
@@ -37527,7 +37532,7 @@ var ProtostoneTransaction = class {
         ),
         // Convert bigint to string for JSON compatibility
         amount: (0, import_integer.u128)(transfer.amount),
-        output: (0, import_integer.u32)(outputIds[address3] + (hasChange ? 1 : 0))
+        output: (0, import_integer.u32)(outputIds[address3] + 1)
       };
       if (!alkanesEdicts[address3]) {
         alkanesEdicts[address3] = {};
@@ -37547,6 +37552,7 @@ var ProtostoneTransaction = class {
         output: edict.output
       }))
     );
+    console.log(transactionEdicts[0]);
     return transactionEdicts;
   }
   addProtostoneData(edicts) {
@@ -42513,6 +42519,53 @@ var ElectrumApiProvider = class {
       );
     }
   }
+  async esplora_getblocktiphash() {
+    try {
+      const requestUrl = `${this.electrumApiUrl}/blocks/tip/hash`;
+      const httpResponse = await fetch(requestUrl);
+      if (!httpResponse.ok) {
+        return new BoxedError(
+          "UnknownError" /* UnknownError */,
+          `Failed to fetch tip hash from ${requestUrl}: ${httpResponse.statusText}`
+        );
+      }
+      const tipHash = (await httpResponse.text()).trim();
+      return new BoxedSuccess(tipHash);
+    } catch (error) {
+      return new BoxedError(
+        "UnknownError" /* UnknownError */,
+        `Failed to fetch tip hash: ${error.message}`
+      );
+    }
+  }
+  async _esplora_getrawblock(blockHash) {
+    try {
+      const requestUrl = `${this.electrumApiUrl}/block/${blockHash}/raw`;
+      const httpResponse = await fetch(requestUrl);
+      if (!httpResponse.ok) {
+        return new BoxedError(
+          "UnknownError" /* UnknownError */,
+          `Failed to fetch raw block ${blockHash} from ${requestUrl}: ${httpResponse.statusText}`
+        );
+      }
+      const bytes = new Uint8Array(await httpResponse.arrayBuffer());
+      const rawHex = Array.from(
+        bytes,
+        (b) => b.toString(16).padStart(2, "0")
+      ).join("");
+      return new BoxedSuccess("0x" + rawHex);
+    } catch (error) {
+      return new BoxedError(
+        "UnknownError" /* UnknownError */,
+        `Failed to fetch raw block ${blockHash}: ${error.message}`
+      );
+    }
+  }
+  async esplora_getrawblocktip() {
+    const tipHashResponse = await this.esplora_getblocktiphash();
+    if (isBoxedError(tipHashResponse)) return tipHashResponse;
+    return this._esplora_getrawblock(tipHashResponse.data);
+  }
   /*
     async esplora_getbulktransactions(
       transactionIds: string[],
@@ -45066,6 +45119,42 @@ var OrdRpcProvider = class {
 
 // src/apis/alkanes/utils.ts
 var stripHex = (s) => s.startsWith("0x") ? s.slice(2) : s;
+function toU64LittleEndianHex(numStr) {
+  const num = BigInt(numStr);
+  const hex = num.toString(16).padStart(16, "0");
+  const bytes = hex.match(/.{2}/g);
+  if (!bytes) throw new Error("Invalid hex conversion");
+  const littleEndian = bytes.reverse().join("");
+  return `0x${littleEndian}`;
+}
+function makeFakeBlock(height) {
+  const buf = new Uint8Array(80);
+  const h = BigInt(height);
+  for (let i = 0; i < 8; i++) {
+    buf[72 + i] = Number(h >> BigInt(8 * i) & 0xffn);
+  }
+  const hex = Array.from(buf, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex}`;
+}
+function toU64BigEndianHex(numStr) {
+  const MAX_U64 = BigInt("0xffffffffffffffff");
+  const num = BigInt(numStr);
+  if (num < 0n || num > MAX_U64) {
+    throw new RangeError("Value exceeds u64 range");
+  }
+  const hex = num.toString(16).padStart(16, "0");
+  return `0x${hex}`;
+}
+function toU128LittleEndianHex(numStr) {
+  const MAX_U1282 = BigInt("0xffffffffffffffffffffffffffffffff");
+  const num = BigInt(numStr);
+  if (num < 0n || num > MAX_U1282) {
+    throw new RangeError("Value exceeds u128 range");
+  }
+  const hex = num.toString(16).padStart(32, "0");
+  const littleEndian = hex.match(/.{2}/g).reverse().join("");
+  return `0x${littleEndian}`;
+}
 function mapToPrimitives(v) {
   switch (typeof v) {
     case "bigint":
@@ -45074,7 +45163,9 @@ function mapToPrimitives(v) {
       if (v === null) return null;
       if (Buffer.isBuffer(v)) return "0x" + v.toString("hex");
       if (Array.isArray(v)) return v.map(mapToPrimitives);
-      return Object.fromEntries(Object.entries(v).map(([k, val]) => [k, mapToPrimitives(val)]));
+      return Object.fromEntries(
+        Object.entries(v).map(([k, val]) => [k, mapToPrimitives(val)])
+      );
     }
     default:
       return v;
@@ -45083,13 +45174,16 @@ function mapToPrimitives(v) {
 function unmapFromPrimitives(v) {
   switch (typeof v) {
     case "string":
-      if (v.startsWith("0x") && v !== "0x") return Buffer.from(stripHex(v), "hex");
+      if (v.startsWith("0x") && v !== "0x")
+        return Buffer.from(stripHex(v), "hex");
       if (!isNaN(v)) return BigInt(v);
       return v;
     case "object": {
       if (v === null) return null;
       if (Array.isArray(v)) return v.map(unmapFromPrimitives);
-      return Object.fromEntries(Object.entries(v).map(([k, val]) => [k, unmapFromPrimitives(val)]));
+      return Object.fromEntries(
+        Object.entries(v).map(([k, val]) => [k, unmapFromPrimitives(val)])
+      );
     }
     default:
       return v;
@@ -45099,7 +45193,9 @@ function parseSimulateReturn(v) {
   if (v === "0x") return void 0;
   const toUtf8 = Buffer.from(stripHex(v), "hex").toString("utf8");
   const isUtf8 = !/[\uFFFD]/.test(toUtf8);
-  const rev = Buffer.from(Array.from(Buffer.from(stripHex(v), "hex")).reverse()).toString("hex");
+  const rev = Buffer.from(
+    Array.from(Buffer.from(stripHex(v), "hex")).reverse()
+  ).toString("hex");
   return {
     string: isUtf8 ? toUtf8 : "0x" + stripHex(v),
     bytes: "0x" + stripHex(v),
@@ -45216,6 +45312,7 @@ var AlkanesRpcProvider = class {
       payload: ["alkanes_trace", [{ txid: leTxid, vout }]],
       call: async () => {
         try {
+          await this.provider.pacer.waitForPacer();
           const encoded = consumeOrThrow(
             await this.rpc("alkanes_trace", [
               { txid: leTxid, vout }
@@ -45287,14 +45384,12 @@ var AlkanesRpcProvider = class {
     ]);
   }
   async alkanes_simulate(req) {
-    const currentHeight = consumeOrThrow(
-      await this.alkanes_metashrewHeight().call()
-    );
+    await this.provider.pacer.waitForPacer();
     const merged = {
       alkanes: req.alkanes ?? [],
       transaction: req.transaction ?? "0x",
       block: "0x",
-      height: req.height ?? currentHeight,
+      height: "908474",
       txindex: req.txindex ?? 0,
       target: {
         block: req.target?.block?.toString() ?? "0",
@@ -45305,6 +45400,7 @@ var AlkanesRpcProvider = class {
       refundPointer: req.refundPointer ?? 0,
       vout: req.vout ?? 0
     };
+    console.log(merged);
     const res = await this.rpc(
       "alkanes_simulate",
       [merged]
@@ -45647,27 +45743,96 @@ var schemaAlkaneId = import_borsher4.BorshSchema.Struct({
   tx: import_borsher4.BorshSchema.u64
 });
 
+// src/pacer.ts
+var WaitPacer = class {
+  maxPerInterval;
+  intervalMs;
+  minGapMs;
+  // track start times within the sliding window
+  starts = [];
+  lastStart = 0;
+  // serialize callers so their start times are paced correctly
+  tail = Promise.resolve();
+  constructor(opts) {
+    this.maxPerInterval = Math.max(1, opts.maxPerInterval);
+    this.intervalMs = Math.max(1, opts.intervalMs);
+    this.minGapMs = Math.floor(this.intervalMs / this.maxPerInterval);
+  }
+  setRate(maxPerInterval, intervalMs) {
+    this.maxPerInterval = Math.max(1, maxPerInterval);
+    this.intervalMs = Math.max(1, intervalMs);
+    this.minGapMs = Math.floor(this.intervalMs / this.maxPerInterval);
+  }
+  now() {
+    return Date.now();
+  }
+  sleep(ms) {
+    return ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
+  }
+  pruneWindow(now) {
+    const cutoff = now - this.intervalMs;
+    while (this.starts.length && this.starts[0] <= cutoff) this.starts.shift();
+  }
+  /** Await this immediately before the call that could rate-limit */
+  waitForPacer() {
+    const ticket = this.tail.then(async () => {
+      while (true) {
+        const now = this.now();
+        this.pruneWindow(now);
+        if (this.starts.length >= this.maxPerInterval) {
+          const earliest = this.starts[0];
+          const waitUntil = earliest + this.intervalMs;
+          await this.sleep(Math.max(0, waitUntil - this.now()));
+          continue;
+        }
+        const earliestStart = this.lastStart + this.minGapMs;
+        const delay = Math.max(0, earliestStart - now);
+        if (delay > 0) {
+          await this.sleep(delay);
+          continue;
+        }
+        const startTs = this.now();
+        this.lastStart = startTs;
+        this.starts.push(startTs);
+        break;
+      }
+    });
+    this.tail = ticket.catch(() => {
+    });
+    return ticket;
+  }
+};
+
 // src/provider.ts
 var Provider = class {
   sandshrewUrl;
   electrumApiUrl;
   network;
   explorerUrl;
+  pacerSettings = {
+    intervalMs: 1e3,
+    maxPerInterval: 10
+  };
   btcTicker;
+  jitterMs = 1e3;
+  // 1 second
   rpc;
   defaultFeeRate;
   TIMEOUT_MS = 6e4 * 5;
   // 5 minutes
   INTERVAL_MS = 5e3;
   // 5 seconds
+  pacer;
   constructor(config) {
     this.sandshrewUrl = config.sandshrewUrl;
     this.electrumApiUrl = config.electrumApiUrl;
     this.network = config.network;
     this.explorerUrl = config.explorerUrl.replace(/\/+$/, "");
     this.btcTicker = config.btcTicker ?? "BTC";
+    this.pacerSettings = config.pacerSettings ?? this.pacerSettings;
     this.defaultFeeRate = config.defaultFeeRate ?? 5;
     this.rpc = new BaseRpcProvider(this);
+    this.pacer = new WaitPacer(this.pacerSettings);
   }
   txUrl(txid) {
     return `${this.explorerUrl}/tx/${txid}`;
@@ -45863,6 +46028,7 @@ bitcoin2.initEccLib(ecc);
   getProtostoneUnsignedPsbtBase64,
   getVSize,
   hexToUint8Array,
+  makeFakeBlock,
   mapToPrimitives,
   minimumFee,
   parseSimulateReturn,
@@ -45876,6 +46042,9 @@ bitcoin2.initEccLib(ecc);
   tapTweakHash,
   toEsploraTx,
   toFormattedUtxo,
+  toU128LittleEndianHex,
+  toU64BigEndianHex,
+  toU64LittleEndianHex,
   trimUndefined,
   tweakSigner,
   u128Schema,