@ledgerhq/coin-kaspa 1.1.0-nightly.0

package/src/logic/tests/utxoSelection.test.ts

@@ -0,0 +1,290 @@
+import { selectUtxos } from "../utxos/selection";
+import { BigNumber } from "bignumber.js";
+import { KaspaUtxo } from "../../types";
+import * as lib from "../utxos/lib";
+
+const TX_MASS_PER_INPUT = 1118;
+const TX_MASS_FOR_TWO_OUTPUTS = 918;
+const TX_MASS_FOR_ECDSA = 11;
+
+export class KaspaUtxoGenerator {
+  static generateUtxo(amount: BigNumber, blockDaaScore: string): KaspaUtxo {
+    return {
+      address: "kaspa:qrp78nf43jaz3zk0j4dxga4ncdzk95xhun95hp6scyh6g6z7kwugy02wfw6ee",
+      outpoint: {
+        transactionId: this.generateRandomTransactionId(),
+        index: this.generateRandomIndex(),
+      },
+      utxoEntry: {
+        amount,
+        scriptPublicKey: {
+          version: 0,
+          scriptPublicKey: this.generateRandomScriptPublicKey(),
+        },
+        blockDaaScore,
+        isCoinbase: true,
+      },
+      accountType: 0,
+      accountIndex: 4,
+    } as KaspaUtxo;
+  }
+
+  static generateUtxoSet(
+    count: number,
+    amount: BigNumber,
+    startBlockDaaScore: string,
+  ): KaspaUtxo[] {
+    const utxos: KaspaUtxo[] = [];
+    for (let i = 0; i < count; i++) {
+      utxos.push(this.generateUtxo(amount, startBlockDaaScore));
+      startBlockDaaScore = (parseInt(startBlockDaaScore) + 1).toString();
+    }
+    return utxos;
+  }
+
+  private static generateRandomTransactionId(): string {
+    const randomBytes = crypto.getRandomValues(new Uint8Array(32));
+    return Array.from(randomBytes)
+      .map(b => b.toString(16).padStart(2, "0"))
+      .join("");
+  }
+
+  private static generateRandomIndex(): number {
+    return Math.floor(Math.random() * 1000);
+  }
+
+  private static generateRandomScriptPublicKey(): string {
+    const randomBytes = crypto.getRandomValues(new Uint8Array(34));
+    return Array.from(randomBytes)
+      .map(b => b.toString(16).padStart(2, "0"))
+      .join("");
+  }
+}
+
+describe("2 outputs - no discard", () => {
+  test("2/5 inputs, 2 outputs", () => {
+    const utxos = KaspaUtxoGenerator.generateUtxoSet(5, BigNumber(1_0000_0000), "12345");
+    const feeRate = 1;
+    const isEcdsaRecipient = false;
+    const selectedUtxos = selectUtxos(utxos, isEcdsaRecipient, BigNumber(1_5000_0000), feeRate);
+
+    expect(utxos.length).toBe(5);
+    // Selected 2 times 1_0000_0000 UTXO
+    expect(selectedUtxos.utxos.length).toBe(2);
+    expect(selectedUtxos.utxos[0].utxoEntry.blockDaaScore).toBe("12345");
+    expect(selectedUtxos.utxos[1].utxoEntry.blockDaaScore).toBe("12346");
+
+    // TX should have: 2 inputs and 2 outputs
+    // compute mass = 3154
+    // storage mass = 6668
+
+    // fee only depends on compute mass
+    expect(selectedUtxos.fee.toNumber()).toBe(3154);
+    expect(selectedUtxos.changeAmount.toNumber()).toBe(2_0000_0000 - 1_5000_0000 - 3154);
+  });
+
+  test("1/5 inputs, 2 outputs", () => {
+    const utxos = KaspaUtxoGenerator.generateUtxoSet(5, BigNumber(2_0000_0000), "12345");
+    const isEcdsaRecipient = false;
+    const feeRate = 1;
+    const sendAmount = BigNumber(1_5000_0000);
+    const selectedUtxos = selectUtxos(utxos, isEcdsaRecipient, sendAmount, feeRate);
+
+    expect(selectedUtxos.utxos.length).toBe(1);
+    expect(selectedUtxos.utxos[0].utxoEntry.blockDaaScore).toBe("12345");
+
+    // TX should be: 1 in + 2 out
+    // compute mass = 2036
+    // storage mass = 21674
+    expect(selectedUtxos.fee.toNumber()).toBe(2036);
+    expect(selectedUtxos.changeAmount.toNumber()).toBe(2_0000_0000 - 1_5000_0000 - 2036);
+  });
+
+  it.each([1, 10, 20, 80, 5000])("5 inputs, 2 outputs, feeRate = %i", feeRate => {
+    const utxos = KaspaUtxoGenerator.generateUtxoSet(15, BigNumber(1_0000_0000), "12345");
+    const isEcdsaRecipient = false;
+    const sendAmount = BigNumber(4_5000_0000);
+    const selectedUtxos = selectUtxos(utxos, isEcdsaRecipient, sendAmount, feeRate);
+
+    expect(selectedUtxos.utxos.length).toBe(5);
+    // TX should be: 1 in + 2 out
+    // compute mass = 1118 * 5 + 918 = 6508
+    // storage mass = 0 ( 5 in and 2 out.. )
+    expect(selectedUtxos.fee.toNumber()).toBe(6508 * feeRate);
+    expect(selectedUtxos.changeAmount.toNumber()).toBe(5_0000_0000 - 4_5000_0000 - 6508 * feeRate);
+  });
+
+  test("5 inputs, 2 outputs, feerate = 8203 => not possible!", () => {
+    const utxos = KaspaUtxoGenerator.generateUtxoSet(5, BigNumber(1_0000_0000), "12345");
+    const feerate = 8203;
+
+    expect(selectUtxos(utxos, false, BigNumber(4_5000_0000), feerate - 1)).toBeDefined();
+    expect(() => selectUtxos(utxos, false, BigNumber(4_5000_0000), feerate)).toThrow(
+      "UTXO total amount is not sufficient for sending amount 450000000",
+    );
+  });
+});
+describe("ECDSA mass", () => {
+  it.each([1, 2, 5])("5 inputs, 2 outputs, feerate = %i, ECDSA", feeRate => {
+    const utxos = KaspaUtxoGenerator.generateUtxoSet(10, BigNumber(1_0000_0000), "12345");
+    const selectedUtxos = selectUtxos(utxos, true, BigNumber(4_5000_0000), feeRate);
+
+    const expectedInputCnt = 5;
+    const computeMass =
+      TX_MASS_FOR_TWO_OUTPUTS + TX_MASS_PER_INPUT * expectedInputCnt + TX_MASS_FOR_ECDSA;
+    const expectedFee = computeMass * feeRate;
+
+    expect(selectedUtxos.utxos.length).toBe(expectedInputCnt);
+    // TX should be: 1 in + 2 out
+    // compute mass = 1118 * 5 + 918 + 11 (ECDSA) = 6508
+    // storage mass = 0 ( 5 in and 2 out.. )
+
+    expect(selectedUtxos.fee.toNumber()).toBe(expectedFee);
+    expect(selectedUtxos.changeAmount.toNumber()).toBe(5_0000_0000 - 4_5000_0000 - expectedFee);
+  });
+  test("2/2 input, 2 outputs, feerate = 1, ECDSA", () => {
+    const utxos = KaspaUtxoGenerator.generateUtxoSet(5, BigNumber(1_0000_0000), "12345");
+    const selectedUtxos = selectUtxos(utxos, true, BigNumber(1_5000_0000), 1);
+
+    expect(utxos.length).toBe(5);
+    expect(selectedUtxos.utxos.length).toBe(2);
+    // TX should be: 2 in + 2 out
+    // compute mass = 3165 (ECDSA)
+    // storage mass = 6668
+    expect(selectedUtxos.fee.toNumber()).toBe(3165);
+    expect(selectedUtxos.changeAmount.toNumber()).toBe(2_0000_0000 - 1_5000_0000 - 3165);
+  });
+});
+describe("2 outputs - no discard", () => {});
+
+describe("1 output with discard", () => {
+  test("check sweetspot - discard up to 1530 sompis change", () => {
+    const feeRate = 1;
+    const utxos = KaspaUtxoGenerator.generateUtxoSet(6, BigNumber(1_0000_0000), "12345");
+    const isEcdsaRecipient = false;
+    const sendAmount = BigNumber(5_0000_0000 - 5 * 1118 - 918 - 1530);
+    const selectedUtxos = selectUtxos(utxos, isEcdsaRecipient, sendAmount, feeRate);
+
+    expect(selectedUtxos.utxos.length).toBe(5);
+    expect(selectedUtxos.fee.toNumber()).toBe(5 * 1118 + 918 + 1530);
+    expect(selectedUtxos.changeAmount.toNumber()).toBe(0);
+
+    const selectedUtxos2 = selectUtxos(utxos, isEcdsaRecipient, sendAmount.minus(1), feeRate);
+    expect(selectedUtxos2.utxos.length).toBe(6);
+    expect(selectedUtxos2.fee.toNumber()).toBe(6 * 1118 + 918);
+    expect(selectedUtxos2.changeAmount.toNumber()).toBe(100000413);
+  });
+
+  test("check sweetspot with feeRate", () => {
+    const feeRate = 2;
+    const utxos = KaspaUtxoGenerator.generateUtxoSet(6, BigNumber(1_0000_0000), "12345");
+    const isEcdsaRecipient = false;
+    const sendAmount = BigNumber(5_0000_0000 - (5 * 1118 + 506) * 2);
+    const selectedUtxos = selectUtxos(utxos, isEcdsaRecipient, sendAmount, feeRate);
+
+    expect(selectedUtxos.utxos.length).toBe(5);
+    expect(selectedUtxos.fee.toNumber()).toBe((5 * 1118 + 506) * 2);
+    expect(selectedUtxos.changeAmount.toNumber()).toBe(0);
+  });
+
+  test("6 inputs, 2 outputs, feerate = 7682 => don't discard change, pick one more UTXO", () => {
+    const utxos = KaspaUtxoGenerator.generateUtxoSet(10, BigNumber(1_0000_0000), "12345");
+    const feerate = 7682;
+    const selectedUtxos = selectUtxos(utxos, false, BigNumber(4_5000_0000), feerate);
+    // in this case the change has to be discarded, as it's only 5544 sompis
+    // and the storage mass explodes to an inacceptable value of 180327402g
+    expect(selectedUtxos.utxos.length).toBe(5);
+    expect(selectedUtxos.fee.toNumber()).toBe(50000000);
+    expect(selectedUtxos.changeAmount.toNumber()).toBe(0);
+  });
+
+  test("6 inputs, 2 outputs, feerate = 8203 => need 6 inputs now.!", () => {
+    const utxos = KaspaUtxoGenerator.generateUtxoSet(6, BigNumber(1_0000_0000), "12345");
+    const feerate = 8203;
+    const selectedUtxos = selectUtxos(utxos, false, BigNumber(4_5000_0000), feerate);
+
+    const expectedInputCnt = 6;
+    const computeMass = TX_MASS_FOR_TWO_OUTPUTS + TX_MASS_PER_INPUT * expectedInputCnt;
+    const expectedFee = computeMass * feerate;
+
+    expect(selectedUtxos.utxos.length).toBe(expectedInputCnt);
+    expect(selectedUtxos.fee.toNumber()).toBe(expectedFee);
+    expect(selectedUtxos.changeAmount.toNumber()).toBe(1_5000_0000 - expectedFee);
+  });
+});
+
+describe("1 output without discard", () => {
+  test("send exact UTXO sum for all UTXOs with no change", () => {
+    const utxos = KaspaUtxoGenerator.generateUtxoSet(5, BigNumber(1_0000_0000), "12345");
+    const feerate = 1;
+    const selectedUtxos = selectUtxos(
+      utxos,
+      false,
+      BigNumber(5_0000_0000 - (5 * 1118 + 506)),
+      feerate,
+    );
+
+    expect(selectedUtxos.utxos.length).toBe(5);
+    expect(selectedUtxos.fee.toNumber()).toBe(5 * 1118 + 506);
+    expect(selectedUtxos.changeAmount.toNumber()).toBe(0);
+  });
+
+  test("send exact UTXO sum for 2 UTXOs with no change", () => {
+    const utxos = KaspaUtxoGenerator.generateUtxoSet(5, BigNumber(1_0000_0000), "12345");
+    const feerate = 1;
+    const selectedUtxos = selectUtxos(
+      utxos,
+      false,
+      BigNumber(2_0000_0000 - (2 * 1118 + 506)),
+      feerate,
+    );
+
+    expect(selectedUtxos.utxos.length).toBe(2);
+    expect(selectedUtxos.fee.toNumber()).toBe(2 * 1118 + 506);
+    expect(selectedUtxos.changeAmount.toNumber()).toBe(0);
+  });
+
+  test("should throw an error if UTXO count exceeds maximum limit", () => {
+    const utxos = KaspaUtxoGenerator.generateUtxoSet(100, BigNumber(1_0000_0000), "0");
+    const feeRate = 1;
+    const isEcdsaRecipient = false;
+
+    expect(() => {
+      selectUtxos(utxos, isEcdsaRecipient, BigNumber(1_0000_0000), feeRate);
+    }).toThrow("UTXO count exceeds the limit of 88 for a TX.");
+  });
+
+  test("should throw an error if discarded change exceeds maximum allowable discard value", () => {
+    const utxos = KaspaUtxoGenerator.generateUtxoSet(10, BigNumber(1_0000_0000), "0");
+    const feeRate = 1;
+    const isEcdsaRecipient = false;
+
+    expect(() => {
+      selectUtxos(utxos, isEcdsaRecipient, BigNumber(1_0000), feeRate);
+    }).toThrow(/Change \d+ Sompis is too high to be discarded./);
+  });
+
+  test("should throw - UTXOs can't be determined to fulfill the specified amount", () => {
+    jest.spyOn(lib, "calcMaxSpendableAmount").mockReturnValue(BigNumber(1_2345_0000));
+    const feeRate = 1;
+    const isEcdsaRecipient = false;
+
+    expect(() => {
+      selectUtxos([], isEcdsaRecipient, BigNumber(1_0000), feeRate);
+    }).toThrow("UTXOs can't be determined to fulfill the specified amount");
+  });
+
+  test("same blockdaascore, still working.", () => {
+    // Generate more UTXOs than the allowed limit (88)
+    const utxos = KaspaUtxoGenerator.generateUtxoSet(2, BigNumber(1_0000_0000), "0");
+    const isEcdsaRecipient = false;
+
+    utxos[1].utxoEntry.blockDaaScore = "0";
+
+    expect(selectUtxos(utxos, isEcdsaRecipient, BigNumber(1_0000_0000)).utxos.length).toBe(2);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+});

package/src/logic/tests/validAddress.test.ts

@@ -0,0 +1,55 @@
+import { isValidKaspaAddress } from "../kaspaAddresses";
+
+describe("isValidKaspaAddress", () => {
+  const testCases = [
+    {
+      input: "kaspa:qq82f9sdsqqkr74memhxt9yrefc8vq9khf5vt6xjp4tscc3pdenmks29mlp9y",
+      expected: true,
+    },
+    {
+      input: "kaspa:qqq7n4n232754kgw6jeu4zu86uerwn4kq9lnl2n2prwl3t2t9hvec720vk9s2",
+      expected: true,
+    },
+    {
+      input: "kaspa:qpc6twj20gxqpeyxvgqe3v4y2ng8t0tawfax89jkf8f24wazmcreu9ggw3crl",
+      expected: true,
+    },
+    // scripthash
+    {
+      input: "kaspa:pp6jt8u5hj3mnjy8v0kk5fg7a8ddnfu7ls7egmqspdtpy0708eervp47e6ls2",
+      expected: true,
+    },
+    // wrong hash for Schnorr
+    {
+      input: "kaspa:qpc6twj20gxqpeyxvgqe3v4y2ng8t0tawfax89jkf8f24wazmcreu9ggw3crr",
+      expected: false,
+    },
+    {
+      input: "kaspa:qyp0r5mcq4rd5grj3652ra09u5dcgwqq9ntuswp247nama5quyj40eq03sc2dkx", // ecdsa
+      expected: true,
+    },
+    // wrong hash for ECDSA
+    {
+      input: "kaspa:qyp0r5mcq4rd5grj3652ra09u5dcgwqq9ntuswp247nama5quyj40eq03sc2dkk", // ecdsa
+      expected: false,
+    },
+    {
+      input: "kaspa:qpc6twj20gxqpeyxvgqe3v4y2ng8t0tawfax89jkf8f24wazmcreu9ggw3crl0", // wrong size
+      expected: false,
+    },
+    {
+      input: "kaspa:qpc6twj20gxqpeyxvgqe3v4y2ng8t0tawfax89jkf8f24wazmcreu9ggw3crb", // unknown char b
+      expected: false,
+    },
+    {
+      input: "kaspa:qpc6twj20gxqpeyxvgqe3v4y2ng8t0tawfax89jkf8f24wazmcreu9ggw3cri", // unknown char i
+      expected: false,
+    },
+  ];
+
+  testCases.forEach(({ input, expected }, index) => {
+    it(`should return ${expected} for test case ${index + 1}`, () => {
+      expect(isValidKaspaAddress(input)).toBe(expected);
+    });
+  });
+});

package/src/logic/utxos/lib.ts

@@ -0,0 +1,40 @@
+import { BigNumber } from "bignumber.js";
+import { KaspaUtxo } from "../../types";
+
+const ADDITIONAL_MASS_PER_INPUT = 1118;
+
+const DEFAULT_MASS_1_OUTPUT: number = 506;
+const MAX_UTXOS_PER_TX: number = 88;
+
+export const calcMaxSpendableAmount = (
+  utxos: KaspaUtxo[],
+  isEcdsaRecipient: boolean,
+  feerate: number = 1,
+): BigNumber => {
+  const maxInputAmount = utxos.reduce(
+    (sum, utxo) => sum.plus(new BigNumber(utxo.utxoEntry.amount)),
+    new BigNumber(0),
+  );
+
+  // storage mass can be neglected here
+  // max compute mass for one output and 88 inputs is 98901
+  let maxSpendableAmount = maxInputAmount.minus(
+    BigNumber(
+      DEFAULT_MASS_1_OUTPUT + Math.min(MAX_UTXOS_PER_TX, utxos.length) * ADDITIONAL_MASS_PER_INPUT,
+    ).times(feerate),
+  );
+
+  if (isEcdsaRecipient) {
+    maxSpendableAmount = maxSpendableAmount.minus(BigNumber(11));
+  }
+
+  return maxSpendableAmount.lt(0) ? BigNumber(0) : maxSpendableAmount;
+};
+
+export const sumBigNumber = (values: BigNumber[]): BigNumber => {
+  return values.reduce((acc, v) => acc.plus(v), BigNumber(0));
+};
+
+export const sumUtxoAmounts = (utxos: KaspaUtxo[]): BigNumber => {
+  return utxos.reduce((acc, v) => acc.plus(v.utxoEntry.amount), BigNumber(0));
+};

package/src/logic/utxos/selection.ts

@@ -0,0 +1,100 @@
+import { BigNumber } from "bignumber.js";
+import { KaspaUtxo } from "../../types";
+import { calcComputeMass, calcStorageMass } from "../massCalcluation";
+import { calcMaxSpendableAmount, sumUtxoAmounts } from "./lib";
+
+const MASS_LIMIT_PER_TX = 100_000; // TX mass must not exceed 100k gram.
+const MASS_PER_INPUT: number = 1118; // Per selected utxo as input, mass increases by this value.
+const MASS_PER_OUTPUT: number = 412; // Per selected utxo as input, mass increases by this value.
+const MAX_UTXOS_PER_TX: number = 88; // 88 is the maximum of utxo inputs in one TX.
+const MAX_DISCARD: number = 2000_0000; // Throw error, if discarded value is higher than this.
+
+export const selectUtxos = (
+  utxos: KaspaUtxo[],
+  isEcdsaRecipient: boolean,
+  amount: BigNumber,
+  feerate: number = 1,
+): { changeAmount: BigNumber; fee: BigNumber; utxos: KaspaUtxo[] } => {
+  // always sort utxos
+  sortUtxos(utxos);
+  // Max UTXO count is 88. More don't fit into a regular TX
+  if (utxos.length > MAX_UTXOS_PER_TX) {
+    throw new Error(`UTXO count exceeds the limit of ${MAX_UTXOS_PER_TX} for a TX.`);
+  }
+
+  // First check in general, if there is enough amount in the UTXOs.
+  if (calcMaxSpendableAmount(utxos, isEcdsaRecipient, feerate).isLessThan(amount)) {
+    throw new Error(`UTXO total amount is not sufficient for sending amount ${amount}`);
+  }
+
+  // Find a sufficient slice.
+  for (let i = 0; i < utxos.length; i++) {
+    const selectedUtxos = utxos.slice(0, i + 1);
+    const selectedUtxoAmount = sumUtxoAmounts(selectedUtxos);
+    // calculate absolute min fee for regular TX with 1 outputs and the given feerate.
+    const minMass = calcComputeMass(i + 1, false, isEcdsaRecipient);
+    const minFee = minMass * feerate;
+
+    // Continue if utxo amount is not enough for transfering amount and fee for miners.
+    if (selectedUtxoAmount.isLessThan(amount.plus(minFee))) {
+      continue;
+    }
+
+    // Here there might be enough UTXOs for the amount + fee.
+    // Now the storage mass could be exceeding the TX limit, with having a low change amount value.
+    // If yes, add another UTXO.
+
+    // Assuming first, it is a valid TX with change ( 2 outputs )
+    const calcFee = feerate * calcComputeMass(i + 1, true, isEcdsaRecipient);
+    let changeAmount = selectedUtxoAmount.minus(amount).minus(calcFee);
+
+    const storageMass = changeAmount.isGreaterThan(0)
+      ? calcStorageMass(
+          selectedUtxos.map(u => u.utxoEntry.amount),
+          [amount, changeAmount],
+        )
+      : 0;
+
+    // If storage mass exceeds the limit or the change amount is negative ( 2 outputs not possible )
+    // Need to pick another UTXO or discard the change.
+    if (changeAmount.isLessThan(0) || storageMass > MASS_LIMIT_PER_TX) {
+      // Picking a further UTXO means a higher mass (one input and output) and thus a higher fee.
+      // Check if the fee is not higher, than just discarding the change.
+      const isWorthPickingAnotherUtxo = changeAmount.isGreaterThan(
+        BigNumber((MASS_PER_INPUT + MASS_PER_OUTPUT) * feerate),
+      );
+      if (i + 1 < utxos.length && isWorthPickingAnotherUtxo) {
+        // There is one more UTXO and it is cheaper to pick than discard the change.
+        continue;
+      } else {
+        // Change needs to be discarded as fee to keep mass low enough.
+        if (changeAmount.isGreaterThan(MAX_DISCARD)) {
+          throw new Error(
+            `Unable to select UTXOs. Change ${changeAmount} Sompis is too high to be discarded.`,
+          );
+        }
+        changeAmount = BigNumber(0);
+      }
+    }
+
+    return {
+      utxos: selectedUtxos,
+      changeAmount,
+      fee: selectedUtxoAmount.minus(amount).minus(changeAmount),
+    };
+  }
+  // Throw an error, if UTXOs can't be determined to fulfill the requirement.
+  throw new Error("UTXOs can't be determined to fulfill the specified amount");
+};
+
+const sortUtxos = (utxos: KaspaUtxo[]) => {
+  utxos.sort((a, b) => {
+    const transactionComparison = a.utxoEntry.blockDaaScore.localeCompare(
+      b.utxoEntry.blockDaaScore,
+    );
+    if (transactionComparison !== 0) {
+      return transactionComparison;
+    }
+    return a.utxoEntry.amount.minus(b.utxoEntry.amount).toNumber();
+  });
+};

package/src/network/config.ts

@@ -0,0 +1,6 @@
+// const API_BASE = "https://api.kaspa.org";
+import { getEnv } from "@ledgerhq/live-env";
+
+const API_BASE = getEnv("API_KASPA_ENDPOINT");
+
+export { API_BASE };

package/src/network/getAddressesActive.ts

@@ -0,0 +1,27 @@
+import { API_BASE } from "./config";
+import { ApiResponseAddressActive } from "../types";
+
+export const getAddressesActive = async (
+  addresses: string[],
+): Promise<ApiResponseAddressActive[]> => {
+  try {
+    const response = await fetch(`${API_BASE}/addresses/active`, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ addresses }),
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch active state for addresses ${addresses}. Status: ${response.status}`,
+      );
+    }
+
+    return (await response.json()) as ApiResponseAddressActive[];
+  } catch (error) {
+    throw new Error(`Error fetching AddressesActives: ${(error as Error).message}`);
+  }
+};

package/src/network/getBalancesForAddresses.ts

@@ -0,0 +1,27 @@
+import { API_BASE } from "./config";
+import { ApiResponseBalance } from "../types";
+
+export const getBalancesForAddresses = async (
+  addresses: string[],
+): Promise<ApiResponseBalance[]> => {
+  try {
+    const response = await fetch(`${API_BASE}/addresses/balances`, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ addresses: addresses }),
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch balance for address ${addresses}. Status: ${response.status}`,
+      );
+    }
+
+    return (await response.json()) as ApiResponseBalance[];
+  } catch (error) {
+    throw new Error(`Error fetching balance: ${(error as Error).message}`);
+  }
+};

package/src/network/getBlockDagInfo.ts

@@ -0,0 +1,22 @@
+import { API_BASE } from "./config";
+import { ApiResponseBlockDagInfo } from "../types";
+
+export const getBlockDagInfo = async (): Promise<ApiResponseBlockDagInfo> => {
+  try {
+    const response = await fetch(`${API_BASE}/info/blockdag`, {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Status: ${response.status}`);
+    }
+
+    const blockDagInfo: ApiResponseBlockDagInfo = await response.json();
+    return blockDagInfo;
+  } catch (error) {
+    throw new Error(`Failed to fetch BlockDAG info. Error: ${error}`);
+  }
+};

package/src/network/getFeeEstimate.ts

@@ -0,0 +1,21 @@
+import { API_BASE } from "./config";
+import { ApiResponseFeeEstimate } from "../types";
+
+export const getFeeEstimate = async (): Promise<ApiResponseFeeEstimate> => {
+  try {
+    const response = await fetch(`${API_BASE}/info/fee-estimate`, {
+      headers: {
+        Accept: "application/json",
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error("Network response was not ok");
+    }
+
+    const fees: ApiResponseFeeEstimate = await response.json();
+    return fees;
+  } catch (error) {
+    throw new Error(`Failed to fetch fee estimate. ${error}`);
+  }
+};

package/src/network/getTransactions.ts

@@ -0,0 +1,25 @@
+import { ApiResponseTransaction } from "../types";
+import { API_BASE } from "./config";
+
+export const getTransactions = async (
+  address: string,
+  after: number = 1,
+): Promise<{ transactions: ApiResponseTransaction[]; nextPageAfter: string | null }> => {
+  const response = await fetch(
+    `${API_BASE}/addresses/${address}/full-transactions-page?resolve_previous_outpoints=light&limit=500&before=0&after=${after}`,
+    {
+      headers: {
+        Accept: "application/json",
+      },
+    },
+  );
+
+  if (!response.ok) {
+    throw new Error("Network response was not ok.");
+  }
+
+  const nextPageAfter = response.headers.get("X-Next-Page-After") || null;
+  const transactions = await response.json();
+
+  return { transactions, nextPageAfter };
+};

package/src/network/getUtxosForAddresses.ts

@@ -0,0 +1,23 @@
+import { API_BASE } from "./config";
+import { ApiResponseUtxo } from "../types";
+
+export const getUtxosForAddresses = async (addresses: string[]): Promise<ApiResponseUtxo[]> => {
+  try {
+    const response = await fetch(`${API_BASE}/addresses/utxos`, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ addresses }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch UTXOs for address ${addresses}. Status: ${response.status}`);
+    }
+
+    return (await response.json()) as ApiResponseUtxo[];
+  } catch (error) {
+    throw new Error(`Error fetching UTXOs: ${(error as Error).message}`);
+  }
+};

package/src/network/getVirtualChainBlueScore.ts

@@ -0,0 +1,21 @@
+import { API_BASE } from "./config";
+
+export const getVirtualChainBlueScore = async (): Promise<number> => {
+  try {
+    const response = await fetch(`${API_BASE}/info/virtual-chain-blue-score`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch virtual-chain-blue-score. Status: ${response.status}`);
+    }
+
+    return (await response.json()).blueScore as number;
+  } catch (error) {
+    throw new Error(`Error fetching virtual chain blue score: ${(error as Error).message}`);
+  }
+};

package/src/network/index.ts

@@ -0,0 +1,8 @@
+export { getAddressesActive } from "./getAddressesActive";
+export { getBalancesForAddresses } from "./getBalancesForAddresses";
+export { getFeeEstimate } from "./getFeeEstimate";
+export { getTransactions } from "./getTransactions";
+export { getUtxosForAddresses } from "./getUtxosForAddresses";
+export { getVirtualChainBlueScore } from "./getVirtualChainBlueScore";
+export { submitTransaction } from "./submitTransaction";
+export { getBlockDagInfo } from "./getBlockDagInfo";