@bitgo-forks/avalanchejs 4.1.0-alpha.1

package/src/utils/address.spec.ts

@@ -0,0 +1,18 @@
+import { base58check } from './base58';
+import { secp256k1 } from '../crypto';
+import * as address from './address';
+
+describe('address', () => {
+  it('parses and formats correctly', async () => {
+    const key = '24jUJ9vZexUM6expyMcT48LBx27k1m7xpraoV62oSQAHdziao5';
+    const privKey = base58check.decode(key);
+    const pubKey = secp256k1.getPublicKey(privKey);
+
+    const addrBytes = secp256k1.publicKeyBytesToAddress(pubKey);
+
+    const addr = address.format('X', 'avax', addrBytes);
+    expect(addr).toEqual('X-avax1lnk637g0edwnqc2tn8tel39652fswa3xmgyghf');
+
+    expect(address.parse(addr)).toEqual(['X', 'avax', addrBytes]);
+  });
+});

package/src/utils/address.ts

@@ -0,0 +1,43 @@
+import { bech32 } from '@scure/base';
+
+const addressSep = '-';
+
+// parse takes in an address string and returns an array of
+// [chain ID alias, bech32 HRP, address bytes].
+export function parse(addrStr: string): [string, string, Uint8Array] {
+  const parts = addrStr.split(addressSep);
+  if (parts.length < 2) {
+    throw new Error(`Invalid address: ${addrStr}`);
+  }
+
+  const chainID = parts[0];
+  const rawAddr = parts[1];
+
+  const [hrp, addr] = parseBech32(rawAddr);
+
+  return [chainID, hrp, addr];
+}
+
+export function bech32ToBytes(addrStr: string): Uint8Array {
+  return parse(addrStr)[2];
+}
+
+// format takes in a chain ID alias, bech32 HRP, and byte slice to produce a
+// string for an address.
+export function format(chainIDAlias: string, hrp: string, addr: Uint8Array) {
+  const addrStr = formatBech32(hrp, addr);
+  return `${chainIDAlias}${addressSep}${addrStr}`;
+}
+
+// parseBech32 takes a bech32 address as input and returns the HRP and data
+// section of a bech32 address.
+export function parseBech32(addrStr: string): [string, Uint8Array] {
+  const { prefix, words } = bech32.decode(addrStr);
+  return [prefix, bech32.fromWords(words)];
+}
+
+// formatBech32 takes an address's bytes as input and returns a bech32 address.
+export function formatBech32(hrp: string, payload: Uint8Array) {
+  const words = bech32.toWords(payload);
+  return bech32.encode(hrp, words);
+}

package/src/utils/addressMap.spec.ts

@@ -0,0 +1,242 @@
+import { jest } from '@jest/globals';
+import { address } from '../fixtures/common';
+import { Address } from '../serializable/fxs/common';
+import { AddressMap, AddressMaps } from './addressMap';
+
+describe('AddressMap', () => {
+  const testAddress1 = address();
+  const testAddress2 = Address.fromHex(
+    '8db97c7cece249c2b98bdc0222cc4c2a57bf52f3',
+  );
+  let testMap: AddressMap;
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    testMap = new AddressMap();
+  });
+
+  it('sets correctly', () => {
+    testMap.set(testAddress1, 3);
+    testMap.set(testAddress2, 1);
+    expect(testMap.get(testAddress1)).toBe(3);
+    expect(testMap.get(testAddress2)).toBe(1);
+    expect(testMap.get(Address.fromHex('333'))).toBeUndefined();
+    expect(testMap.has(Address.fromHex('333'))).toBeFalsy();
+    expect(testMap.size()).toBe(2);
+
+    const keys: [number, Address][] = [];
+    testMap.forEach((val, key) => {
+      keys.push([val, key]);
+    });
+    expect(keys.length).toBe(2);
+    expect(keys[0][0]).toBe(3);
+    expect(keys[0][1].toHex()).toBe(testAddress1.toHex());
+    expect(keys[1][0]).toBe(1);
+    expect(keys[1][1].toHex()).toBe(testAddress2.toHex());
+  });
+
+  describe('forEachHex', () => {
+    it('iterates over the storage correctly', () => {
+      const callbackMock = jest.fn();
+      testMap.set(testAddress1, 3);
+      testMap.set(testAddress2, 1);
+
+      testMap.forEachHex(callbackMock);
+
+      expect(callbackMock).toBeCalledTimes(2);
+      expect(callbackMock).toHaveBeenNthCalledWith(
+        1,
+        3,
+        testAddress1.toHex(),
+        testMap.storage,
+      );
+      expect(callbackMock).toHaveBeenNthCalledWith(
+        2,
+        1,
+        testAddress2.toHex(),
+        testMap.storage,
+      );
+    });
+
+    it('reorders and iterates over the storage correctly', () => {
+      const callbackMock = jest.fn();
+      testMap.set(testAddress1, 3);
+      testMap.set(testAddress2, 1);
+
+      const expectedSortedMap = new AddressMap([
+        [testAddress2, 0],
+        [testAddress1, 1],
+      ]);
+
+      testMap.forEachHex(callbackMock, true);
+
+      expect(callbackMock).toBeCalledTimes(2);
+      expect(callbackMock).toHaveBeenNthCalledWith(
+        1,
+        0,
+        testAddress2.toHex(),
+        expectedSortedMap.storage,
+      );
+      expect(callbackMock).toHaveBeenNthCalledWith(
+        2,
+        1,
+        testAddress1.toHex(),
+        expectedSortedMap.storage,
+      );
+    });
+  });
+});
+
+describe('AddressMaps', () => {
+  const testAddress1 = address();
+  const testAddress2 = Address.fromHex(
+    '8db97c7cece249c2b98bdc0222cc4c2a57bf52f3',
+  );
+  const testAddress3 = Address.fromHex(
+    '8db97c7cece219c2b98bdc0222cc4c2a57bf52f3',
+  );
+
+  const testMap1 = new AddressMap();
+  testMap1.set(testAddress1, 3);
+  testMap1.set(testAddress2, 1);
+  const testMap2 = new AddressMap();
+  testMap2.set(testAddress3, 2);
+  testMap2.set(testAddress2, 6);
+
+  const testAddressMaps = new AddressMaps();
+  testAddressMaps.push(testMap1);
+  testAddressMaps.push(testMap2);
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe('forEach', () => {
+    it('iterates over the indices correctly', () => {
+      const callbackMock = jest.fn();
+      testAddressMaps.forEach(callbackMock);
+
+      expect(callbackMock).toBeCalledTimes(3);
+      expect(callbackMock).toHaveBeenNthCalledWith(
+        1,
+        [[0, 3]],
+        testAddress1.toHex(),
+      );
+      expect(callbackMock).toHaveBeenNthCalledWith(
+        2,
+        [
+          [0, 1],
+          [1, 6],
+        ],
+        testAddress2.toHex(),
+      );
+      expect(callbackMock).toHaveBeenNthCalledWith(
+        3,
+        [[1, 2]],
+        testAddress3.toHex(),
+      );
+    });
+
+    it('iterates over the ordered indices correctly', () => {
+      const callbackMock = jest.fn();
+      testAddressMaps.forEach(callbackMock, true);
+
+      expect(callbackMock).toBeCalledTimes(3);
+      expect(callbackMock).toHaveBeenNthCalledWith(
+        1,
+        [
+          [0, 0],
+          [1, 1],
+        ],
+        testAddress2.toHex(),
+      );
+      expect(callbackMock).toHaveBeenNthCalledWith(
+        2,
+        [[0, 1]],
+        testAddress1.toHex(),
+      );
+      expect(callbackMock).toHaveBeenNthCalledWith(
+        3,
+        [[1, 0]],
+        testAddress3.toHex(),
+      );
+    });
+  });
+
+  it('pushes and getAddresses correctly', () => {
+    expect(testAddressMaps.getSigIndicesForAddress(testAddress1)).toStrictEqual(
+      [[0, 3]],
+    );
+    expect(testAddressMaps.getSigIndicesForAddress(testAddress2)).toStrictEqual(
+      [
+        [0, 1],
+        [1, 6],
+      ],
+    );
+    expect(testAddressMaps.getSigIndicesForAddress(testAddress3)).toStrictEqual(
+      [[1, 2]],
+    );
+
+    // ordered
+    expect(
+      testAddressMaps.getSigIndicesForAddress(testAddress1, true),
+    ).toStrictEqual([[0, 1]]);
+    expect(
+      testAddressMaps.getSigIndicesForAddress(testAddress2, true),
+    ).toStrictEqual([
+      [0, 0],
+      [1, 1],
+    ]);
+    expect(
+      testAddressMaps.getSigIndicesForAddress(testAddress3, true),
+    ).toStrictEqual([[1, 0]]);
+
+    const testAddressMaps2 = new AddressMaps();
+    testAddressMaps.push(testMap1);
+    testAddressMaps.push(testMap2);
+
+    testAddressMaps2.merge(testAddressMaps);
+    expect(
+      testAddressMaps2.getSigIndicesForAddress(testAddress1),
+    ).toStrictEqual([
+      [0, 3],
+      [2, 3],
+    ]);
+    expect(
+      testAddressMaps2.getSigIndicesForAddress(testAddress2),
+    ).toStrictEqual([
+      [0, 1],
+      [1, 6],
+      [2, 1],
+      [3, 6],
+    ]);
+    expect(
+      testAddressMaps2.getSigIndicesForAddress(testAddress3),
+    ).toStrictEqual([
+      [1, 2],
+      [3, 2],
+    ]);
+
+    // ordered
+    expect(
+      testAddressMaps2.getSigIndicesForAddress(testAddress1, true),
+    ).toStrictEqual([
+      [0, 1],
+      [2, 1],
+    ]);
+    expect(
+      testAddressMaps2.getSigIndicesForAddress(testAddress2, true),
+    ).toStrictEqual([
+      [0, 0],
+      [1, 1],
+      [2, 0],
+      [3, 1],
+    ]);
+    expect(
+      testAddressMaps2.getSigIndicesForAddress(testAddress3, true),
+    ).toStrictEqual([
+      [1, 0],
+      [3, 0],
+    ]);
+  });
+});

package/src/utils/addressMap.ts

@@ -0,0 +1,183 @@
+import type { TransferableInput } from '../serializable';
+import type { Utxo } from '../serializable/avax/utxo';
+import { Address } from '../serializable/fxs/common';
+import { addressesFromBytes } from './addressesFromBytes';
+import { hexToBuffer } from './buffer';
+import { matchOwners } from './matchOwners';
+
+export class AddressMap {
+  constructor(initialData: [Address, number][] = []) {
+    initialData.forEach(([address, num]) => {
+      this.set(address, num);
+    });
+  }
+
+  storage = new Map<string, number>();
+
+  set(add: Address, item: number) {
+    this.storage.set(add.toHex(), item);
+    return this;
+  }
+
+  toJSON() {
+    return Array.from(this.storage.entries());
+  }
+
+  static fromJSON(maps: [string, number][]) {
+    return new AddressMap(
+      maps.map(([addressHex, idx]) => [Address.fromHex(addressHex), idx]),
+    );
+  }
+
+  get(add: Address): number | undefined {
+    return this.storage.get(add.toHex());
+  }
+
+  has(add: Address): boolean {
+    return this.storage.has(add.toHex());
+  }
+
+  size() {
+    return this.storage.size;
+  }
+
+  forEach(cb: (value: number, key: Address) => void) {
+    return this.storage.forEach((val, key) => cb(val, Address.fromHex(key)));
+  }
+
+  forEachHex(
+    cb: (value: number, key: string) => void,
+    shouldReorderWithoutGaps = false,
+  ) {
+    // reorder the sigindices, so they start from index 0, without gaps
+    if (shouldReorderWithoutGaps) {
+      return AddressMap.fromJSON(
+        [...this.storage.entries()]
+          .sort((a, b) => a[1] - b[1])
+          .map(([addressHex], index) => [addressHex, index]),
+      ).storage.forEach(cb);
+    }
+
+    return this.storage.forEach(cb);
+  }
+
+  values() {
+    return this.storage.values();
+  }
+}
+
+export class AddressMaps {
+  constructor(addressMaps: AddressMap[] = []) {
+    if (addressMaps.length) {
+      this.push(...addressMaps);
+    }
+  }
+
+  private storage: AddressMap[] = [];
+  private index: Record<string, [number, number][]> = {};
+  private orderedIndex: Record<string, [number, number][]> = {};
+
+  push(...addressMaps: AddressMap[]) {
+    addressMaps.forEach((addressMap) => {
+      addressMap.forEachHex((index, addressHex) => {
+        this.index[addressHex] = this.index[addressHex] ?? [];
+        this.index[addressHex].push([this.storage.length, index]);
+      });
+
+      addressMap.forEachHex((index, addressHex) => {
+        this.orderedIndex[addressHex] = this.orderedIndex[addressHex] ?? [];
+        this.orderedIndex[addressHex].push([this.storage.length, index]);
+      }, true);
+
+      this.storage.push(addressMap);
+    });
+  }
+
+  // this is a stopgap to quickly fix AddressMap not deriving the order post sorting TransferableInputs. Can probably
+  // be simplified a lot by just deriving the sigIndicies right before returning the unsingedTx
+  static fromTransferableInputs(
+    inputs: TransferableInput[],
+    inputUtxos: Utxo[],
+    minIssuanceTime: bigint,
+    fromAddressesBytes?: Uint8Array[],
+  ) {
+    const utxoMap = inputUtxos.reduce((agg, utxo) => {
+      return agg.set(utxo.utxoId.ID(), utxo);
+    }, new Map<string, Utxo>());
+
+    const addressMaps = inputs.map((input, i) => {
+      const utxo = utxoMap.get(input.utxoID.ID());
+      if (!utxo) throw new Error('input utxo not found');
+
+      if (fromAddressesBytes) {
+        const fromAddresses = addressesFromBytes(fromAddressesBytes);
+
+        const sigData = matchOwners(
+          utxo.getOutputOwners(),
+          fromAddresses,
+          minIssuanceTime,
+          input.sigIndicies(), // we care about signers only
+        );
+
+        if (!sigData) {
+          throw new Error(`input ${i} has no valid owners`);
+        }
+        return sigData.addressMap;
+      }
+
+      // in case fromAddressesBytes were not provided,
+      // get the them from the provided UTXOs using the inputs' signature indices
+      const addressMapData = input.sigIndicies().map((sigIndex) => {
+        const address = utxo.getOutputOwners().addrs[sigIndex];
+        return [address, sigIndex] as [Address, number];
+      });
+
+      return new AddressMap(addressMapData);
+    });
+
+    return new AddressMaps(addressMaps);
+  }
+
+  toJSON() {
+    return this.storage;
+  }
+
+  static fromJSON(addressMaps: [string, number][][]) {
+    return new AddressMaps(addressMaps.map((map) => AddressMap.fromJSON(map)));
+  }
+
+  getAddresses(): Uint8Array[] {
+    return Object.keys(this.index).map((hex) => hexToBuffer(hex));
+  }
+
+  forEach(
+    cb: (coordinates: [number, number][], address: string) => void,
+    useReorderedIndices = false,
+  ) {
+    Object.entries(
+      useReorderedIndices ? this.orderedIndex : this.index,
+    ).forEach(([address, coordinates]) => {
+      cb(coordinates, address);
+    });
+  }
+
+  has(address: Address): boolean {
+    return address.toHex() in this.index;
+  }
+
+  toArray() {
+    return this.storage;
+  }
+
+  merge(newMap: AddressMaps) {
+    newMap.toArray().forEach((map) => this.push(map));
+  }
+
+  getSigIndicesForAddress(address: Address, useReorderedIndices = false) {
+    if (useReorderedIndices) {
+      return this.orderedIndex[address.toHex()];
+    }
+
+    return this.index[address.toHex()];
+  }
+}

package/src/utils/addressesFromBytes.ts

@@ -0,0 +1,5 @@
+import { Address } from '../serializable/fxs/common';
+
+export function addressesFromBytes(bytes: Uint8Array[]): Address[] {
+  return bytes.map((b) => new Address(b));
+}

package/src/utils/avaxToNAvax.ts

@@ -0,0 +1 @@
+export const AvaxToNAvax = (num: number) => BigInt(num * 1e9);

package/src/utils/base58.spec.ts

@@ -0,0 +1,51 @@
+import { base58, base58check } from './base58';
+
+describe('base58', () => {
+  it('encodes and decodes correctly', async () => {
+    const tests = [
+      {
+        buffer: new Uint8Array([
+          0x00, 0xfe, 0x7b, 0xd0, 0xe0, 0x03, 0x2b, 0x8d, 0x2c, 0x11, 0x56,
+          0x84, 0x1f, 0xa0, 0x60, 0x14, 0x56, 0xaa, 0xac, 0x8f, 0x3c, 0x0e,
+          0xf1, 0x6d, 0x8c,
+        ]),
+        string: '1QCaxc8hutpdZ62iKZsn1TCG3nh7uPZojq',
+        checksum: '13cp39pSRSMbaxjaXZfFLXuiiK4FHDBQRBm35ab2',
+      },
+      {
+        buffer: new Uint8Array([
+          0x00, 0x8b, 0x46, 0xd2, 0x54, 0xa0, 0x83, 0xd1, 0x0c, 0xe3, 0xf1,
+          0x2f, 0x5e, 0x95, 0x43, 0xba, 0x73, 0x1f, 0x21, 0xf2, 0xa9, 0x6f,
+          0xeb, 0x2a, 0x60,
+        ]),
+        string: '1DhRmSGnhPjUaVPAj48zgPV9e2oRhAQFUb',
+        checksum: '12S5vHShaePQQAXjmjLC87s1Kxi9uM6YEkS2K5Hh',
+      },
+      {
+        buffer: new Uint8Array([
+          0x00, 0x45, 0x7a, 0x36, 0xbb, 0x6b, 0xee, 0xe4, 0xea, 0xd3, 0x60,
+          0x95, 0x37, 0xda, 0x65, 0x8c, 0x02, 0x62, 0x3e, 0xbe, 0x88, 0x08,
+          0x6d, 0x18, 0xc7,
+        ]),
+        string: '17LN2oPYRYsXS9TdYdXCCDvF2FegshLDU2',
+        checksum: '1iSthZt2SDsWS3ELSjFkRsikVNtWDT1GmYzvPQQ',
+      },
+      {
+        buffer: new Uint8Array([
+          0x00, 0x28, 0x7a, 0x57, 0xcd, 0xbe, 0x7b, 0x5c, 0xf8, 0x0f, 0x76,
+          0x30, 0x9b, 0x29, 0x75, 0x6d, 0x25, 0x86, 0x60, 0x07, 0x2b, 0x30,
+          0xda, 0x67, 0x7b,
+        ]),
+        string: '14h2bDLZSuvRFhUL45VjPHJcW667mmRAAn',
+        checksum: '1R9XA3AmWSAkSF6krDfnDmLjMQbtuz7ED7jDMbt',
+      },
+    ];
+
+    for (const { buffer, string, checksum } of tests) {
+      expect(base58.encode(buffer)).toEqual(string);
+      expect(base58.decode(string)).toEqual(buffer);
+      expect(base58check.encode(buffer)).toEqual(checksum);
+      expect(base58check.decode(checksum)).toEqual(buffer);
+    }
+  });
+});

package/src/utils/base58.ts

@@ -0,0 +1,15 @@
+import { base58 } from '@scure/base';
+import type { BytesCoder } from '@scure/base';
+import { sha256 } from '@noble/hashes/sha256';
+import { concatBytes } from './buffer';
+
+export const base58check: BytesCoder = {
+  encode(data) {
+    return base58.encode(concatBytes(data, sha256(data).subarray(-4)));
+  },
+  decode(string) {
+    return base58.decode(string).subarray(0, -4);
+  },
+};
+
+export { base58 } from '@scure/base';

package/src/utils/bigintMath.ts

@@ -0,0 +1,2 @@
+export const bigIntMin = (...args: bigint[]): bigint =>
+  args.reduce((m, e) => (e < m ? e : m));

package/src/utils/buffer.spec.ts

@@ -0,0 +1,80 @@
+import { bufferToBigInt, bufferToNumber, padLeft } from './buffer';
+
+describe('bufferToBigInt', () => {
+  it('converts Uint8Arrays correctly', async () => {
+    const tests = [
+      {
+        buffer: new Uint8Array([0x00, 0x00]),
+        number: 0n,
+      },
+      {
+        buffer: new Uint8Array([0x00, 0x00, 0x00, 0x07]),
+        number: 7n,
+      },
+      {
+        buffer: new Uint8Array([
+          0x00, 0x00, 0x00, 0x00, 0x77, 0x35, 0x94, 0x00,
+        ]),
+        number: 2_000_000_000n,
+      },
+    ];
+
+    for (const { buffer, number } of tests) {
+      expect(bufferToBigInt(buffer)).toEqual(number);
+    }
+  });
+});
+
+describe('bufferToNumber', () => {
+  it('converts Uint8Arrays correctly', async () => {
+    const tests = [
+      {
+        buffer: new Uint8Array([0x00, 0x00]),
+        number: 0,
+      },
+      {
+        buffer: new Uint8Array([0x00, 0x00, 0x00, 0x07]),
+        number: 7,
+      },
+      {
+        buffer: new Uint8Array([
+          0x00, 0x00, 0x00, 0x00, 0x77, 0x35, 0x94, 0x00,
+        ]),
+        number: 2_000_000_000,
+      },
+    ];
+
+    for (const { buffer, number } of tests) {
+      expect(bufferToNumber(buffer)).toEqual(number);
+    }
+  });
+});
+
+describe('padLeft', () => {
+  it('pads to 2 bytes', () => {
+    const res = padLeft(new Uint8Array([0x72]), 2);
+    expect(res).toStrictEqual(new Uint8Array([0x00, 0x72]));
+  });
+
+  it('pads to 4 bytes', () => {
+    const res = padLeft(new Uint8Array([0x72]), 4);
+    expect(res).toStrictEqual(new Uint8Array([0x00, 0x00, 0x00, 0x72]));
+  });
+
+  it('pads to 8 bytes', () => {
+    const res = padLeft(new Uint8Array([0x72]), 8);
+    expect(res).toStrictEqual(
+      new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72]),
+    );
+  });
+
+  it('pads if empty array', () => {
+    const res = padLeft(new Uint8Array([]), 2);
+    expect(res).toStrictEqual(new Uint8Array([0x00, 0x00]));
+  });
+
+  it('no-ops if already at size', () => {
+    const res = padLeft(new Uint8Array([0xaf, 0x72, 0x72]), 2);
+    expect(res).toStrictEqual(new Uint8Array([0xaf, 0x72, 0x72]));
+  });
+});

package/src/utils/buffer.ts

@@ -0,0 +1,36 @@
+import { bytesToHex, concatBytes, hexToBytes } from '@noble/hashes/utils';
+import { add0x, strip0x } from 'micro-eth-signer';
+
+export function bufferToBigInt(buf: Uint8Array) {
+  return BigInt(bufferToHex(buf));
+}
+
+export function bufferToNumber(buf: Uint8Array) {
+  return Number.parseInt(bytesToHex(buf), 16);
+}
+
+export function bufferToHex(buf: Uint8Array) {
+  return add0x(bytesToHex(buf));
+}
+
+export function hexToBuffer(hex: string) {
+  hex = strip0x(hex);
+  if (hex.length & 1) {
+    hex = '0' + hex;
+  }
+  return hexToBytes(hex);
+}
+
+export function padLeft(bytes: Uint8Array, length: number) {
+  const offset = length - bytes.length;
+
+  if (offset <= 0) {
+    return bytes;
+  }
+
+  const out = new Uint8Array(length);
+  out.set(bytes, offset);
+  return out;
+}
+
+export { concatBytes, strip0x, add0x };