@bitgo-forks/avalanchejs 4.1.0-alpha.1

package/src/fixtures/primitives.ts

@@ -0,0 +1,62 @@
+import {
+  BigIntPr,
+  Byte,
+  Bytes,
+  Int,
+  Short,
+  Stringpr,
+} from '../serializable/primitives';
+import { concatBytes } from '../utils/buffer';
+import { bytesForInt } from './utils/bytesFor';
+
+export const intBytes = () => new Uint8Array([0x00, 0x00, 0x00, 0x0d]);
+
+export const int = () => new Int(13);
+
+export const intsBytes = () =>
+  concatBytes(bytesForInt(3), bytesForInt(3), bytesForInt(2), bytesForInt(1));
+
+export const ints = () => [new Int(3), new Int(2), new Int(1)];
+
+export const byteByte = () => new Uint8Array([0x01]);
+
+export const byte = () => new Byte(new Uint8Array([0x01]));
+
+export const bytesBytes = () =>
+  concatBytes(bytesForInt(2), new Uint8Array([0x01, 0x02]));
+
+export const bytes = () => new Bytes(new Uint8Array([0x01, 0x02]));
+
+export const bigIntPrBytes = () =>
+  new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x84, 0x80]);
+
+export const bigIntPr = () => new BigIntPr(2000000n);
+
+export const stringPr = () => new Stringpr('Avax');
+
+export const stringPrBytes = () =>
+  new Uint8Array([0x00, 0x04, 0x41, 0x76, 0x61, 0x78]);
+
+export const shortBytes = () => new Uint8Array([0x00, 0x0d]);
+
+export const short = () => new Short(13);
+
+export const blsPublicKeyBytes = () =>
+  new Uint8Array([
+    0x85, 0x02, 0x5b, 0xca, 0x6a, 0x30, 0x2d, 0xc6, 0x13, 0x38, 0xff, 0x49,
+    0xc8, 0xba, 0xa5, 0x72, 0xde, 0xd3, 0xe8, 0x6f, 0x37, 0x59, 0x30, 0x4c,
+    0x7f, 0x61, 0x8a, 0x2a, 0x25, 0x93, 0xc1, 0x87, 0xe0, 0x80, 0xa3, 0xcf,
+    0xde, 0xc9, 0x50, 0x40, 0x30, 0x9a, 0xd1, 0xf1, 0x58, 0x95, 0x30, 0x67,
+  ]);
+
+export const blsSignatureBytes = () =>
+  new Uint8Array([
+    0x8b, 0x1d, 0x61, 0x33, 0xd1, 0x7e, 0x34, 0x83, 0x22, 0x0a, 0xd9, 0x60,
+    0xb6, 0xfd, 0xe1, 0x1e, 0x4e, 0x12, 0x14, 0xa8, 0xce, 0x21, 0xef, 0x61,
+    0x62, 0x27, 0xe5, 0xd5, 0xee, 0xf0, 0x70, 0xd7, 0x50, 0x0e, 0x6f, 0x7d,
+    0x44, 0x52, 0xc5, 0xa7, 0x60, 0x62, 0x0c, 0xc0, 0x67, 0x95, 0xcb, 0xe2,
+    0x18, 0xe0, 0x72, 0xeb, 0xa7, 0x6d, 0x94, 0x78, 0x8d, 0x9d, 0x01, 0x17,
+    0x6c, 0xe4, 0xec, 0xad, 0xfb, 0x96, 0xb4, 0x7f, 0x94, 0x22, 0x81, 0x89,
+    0x4d, 0xdf, 0xad, 0xd1, 0xc1, 0x74, 0x3f, 0x7f, 0x54, 0x9f, 0x1d, 0x07,
+    0xd5, 0x9d, 0x55, 0x65, 0x59, 0x27, 0xf7, 0x2b, 0xc6, 0xbf, 0x7c, 0x12,
+  ]);

package/src/fixtures/pvm.ts

@@ -0,0 +1,292 @@
+import { concatBytes } from '@noble/hashes/utils';
+import {
+  AddDelegatorTx,
+  AddPermissionlessDelegatorTx,
+  AddPermissionlessValidatorTx,
+  AddSubnetValidatorTx,
+  AddValidatorTx,
+  AdvanceTimeTx,
+  CreateChainTx,
+  CreateSubnetTx,
+  ExportTx,
+  ImportTx,
+  ProofOfPossession,
+  Signer,
+  StakeableLockIn,
+  StakeableLockOut,
+  SubnetValidator,
+  Validator,
+  RemoveSubnetValidatorTx,
+  TransferSubnetOwnershipTx,
+  TransformSubnetTx,
+} from '../serializable/pvm';
+import {
+  baseTx,
+  baseTxbytes,
+  transferableInput,
+  transferableInputBytes,
+  transferableOutput,
+  transferableOutputBytes,
+} from './avax';
+import { id, idBytes, nodeId, nodeIdBytes } from './common';
+import {
+  bigIntPr,
+  bigIntPrBytes,
+  bytes,
+  bytesBytes,
+  int,
+  intBytes,
+  blsPublicKeyBytes,
+  blsSignatureBytes,
+  stringPr,
+  stringPrBytes,
+  byte,
+  byteByte,
+} from './primitives';
+import {
+  input,
+  inputBytes,
+  outputOwner,
+  outputOwnerBytes,
+  transferInput,
+  transferInputBytes,
+  transferOutput,
+  transferOutputBytes,
+} from './secp256k1';
+import { bytesForInt } from './utils/bytesFor';
+import { makeList, makeListBytes } from './utils/makeList';
+
+export const validator = () =>
+  new Validator(nodeId(), bigIntPr(), bigIntPr(), bigIntPr());
+
+export const validatorBytes = () =>
+  concatBytes(nodeIdBytes(), bigIntPrBytes(), bigIntPrBytes(), bigIntPrBytes());
+
+export const addValidatorTx = () =>
+  new AddValidatorTx(
+    baseTx(),
+    validator(),
+    makeList(transferableOutput)(),
+    outputOwner(),
+    int(),
+  );
+export const addValidatorTxBytes = () =>
+  concatBytes(
+    baseTxbytes(),
+    validatorBytes(),
+    makeListBytes(transferableOutputBytes)(),
+    bytesForInt(11),
+    outputOwnerBytes(),
+    intBytes(),
+  );
+
+export const subnetValidator = () => new SubnetValidator(validator(), id());
+
+export const subnetValidatorBytes = () =>
+  concatBytes(validatorBytes(), idBytes());
+
+export const addSubnetValidatorTx = () =>
+  new AddSubnetValidatorTx(baseTx(), subnetValidator(), input());
+
+export const addSubnetValidatorTxBytes = () =>
+  concatBytes(
+    baseTxbytes(),
+    subnetValidatorBytes(),
+    bytesForInt(10),
+    inputBytes(),
+  );
+
+export const addDelegatorTx = () =>
+  new AddDelegatorTx(
+    baseTx(),
+    validator(),
+    makeList(transferableOutput)(),
+    outputOwner(),
+  );
+
+export const addDelegatorTxBytes = () =>
+  concatBytes(
+    baseTxbytes(),
+    validatorBytes(),
+    makeListBytes(transferableOutputBytes)(),
+    bytesForInt(11),
+    outputOwnerBytes(),
+  );
+
+export const createChainTx = () =>
+  new CreateChainTx(
+    baseTx(),
+    id(),
+    stringPr(),
+    id(),
+    makeList(id)(),
+    bytes(),
+    input(),
+  );
+
+export const createChainTxBytes = () =>
+  concatBytes(
+    baseTxbytes(),
+    idBytes(),
+    stringPrBytes(),
+    idBytes(),
+    makeListBytes(idBytes)(),
+    bytesBytes(),
+    bytesForInt(10),
+    inputBytes(),
+  );
+
+export const createSubnetTx = () => new CreateSubnetTx(baseTx(), outputOwner());
+export const removeValidatorTx = () =>
+  new RemoveSubnetValidatorTx(baseTx(), nodeId(), id(), input());
+
+export const createSubnetTxBytes = () =>
+  concatBytes(baseTxbytes(), bytesForInt(11), outputOwnerBytes());
+
+export const importTx = () =>
+  new ImportTx(baseTx(), id(), makeList(transferableInput)());
+
+export const importTxBytes = () =>
+  concatBytes(
+    baseTxbytes(),
+    idBytes(),
+    makeListBytes(transferableInputBytes)(),
+  );
+
+export const exportTx = () =>
+  new ExportTx(baseTx(), id(), makeList(transferableOutput)());
+
+export const exportTxBytes = () =>
+  concatBytes(
+    baseTxbytes(),
+    idBytes(),
+    makeListBytes(transferableOutputBytes)(),
+  );
+
+export const removeSubnetValidatorTxBytes = () =>
+  concatBytes(
+    baseTxbytes(),
+    nodeIdBytes(),
+    idBytes(),
+    bytesForInt(10),
+    inputBytes(),
+  );
+
+export const stakeableLockIn = () =>
+  new StakeableLockIn(bigIntPr(), transferInput());
+
+export const stakeableLockInBytes = () =>
+  concatBytes(bigIntPrBytes(), bytesForInt(5), transferInputBytes());
+
+export const stakeableLockOut = () =>
+  new StakeableLockOut(bigIntPr(), transferOutput());
+
+export const stakeableLockOutBytes = () =>
+  concatBytes(bigIntPrBytes(), bytesForInt(7), transferOutputBytes());
+
+export const advanceTimeTx = () => new AdvanceTimeTx(bigIntPr());
+
+export const advanceTimeBytesTx = () => bigIntPrBytes();
+
+export const proofOfPossession = () =>
+  new ProofOfPossession(blsPublicKeyBytes(), blsSignatureBytes());
+
+export const signer = () => new Signer(proofOfPossession());
+export const signerBytes = () =>
+  concatBytes(blsPublicKeyBytes(), blsSignatureBytes());
+
+export const addPermissionlessValidatorTx = () =>
+  new AddPermissionlessValidatorTx(
+    baseTx(),
+    subnetValidator(),
+    signer(),
+    makeList(transferableOutput)(),
+    outputOwner(),
+    outputOwner(),
+    int(),
+  );
+
+export const addPermissionlessValidatorTxBytes = () =>
+  concatBytes(
+    baseTxbytes(),
+    subnetValidatorBytes(),
+    bytesForInt(28),
+    signerBytes(),
+    makeListBytes(transferableOutputBytes)(),
+    bytesForInt(11),
+    outputOwnerBytes(),
+    bytesForInt(11),
+    outputOwnerBytes(),
+    intBytes(),
+  );
+
+export const addPermissionlessDelegatorTx = () =>
+  new AddPermissionlessDelegatorTx(
+    baseTx(),
+    subnetValidator(),
+    makeList(transferableOutput)(),
+    outputOwner(),
+  );
+
+export const addPermissionlessDelegatorTxBytes = () =>
+  concatBytes(
+    baseTxbytes(),
+    subnetValidatorBytes(),
+    makeListBytes(transferableOutputBytes)(),
+    bytesForInt(11),
+    outputOwnerBytes(),
+  );
+
+export const transferSubnetOwnershipTx = () =>
+  new TransferSubnetOwnershipTx(baseTx(), id(), input(), outputOwner());
+
+export const transferSubnetOwnershipTxBytes = () =>
+  concatBytes(
+    baseTxbytes(),
+    idBytes(),
+    bytesForInt(10),
+    inputBytes(),
+    bytesForInt(11),
+    outputOwnerBytes(),
+  );
+
+export const transformSubnetTx = () =>
+  new TransformSubnetTx(
+    baseTx(),
+    id(),
+    id(),
+    bigIntPr(),
+    bigIntPr(),
+    bigIntPr(),
+    bigIntPr(),
+    bigIntPr(),
+    bigIntPr(),
+    int(),
+    int(),
+    int(),
+    int(),
+    byte(),
+    int(),
+    input(),
+  );
+
+export const transformSubnetTxBytes = () =>
+  concatBytes(
+    baseTxbytes(),
+    idBytes(),
+    idBytes(),
+    bigIntPrBytes(),
+    bigIntPrBytes(),
+    bigIntPrBytes(),
+    bigIntPrBytes(),
+    bigIntPrBytes(),
+    bigIntPrBytes(),
+    intBytes(),
+    intBytes(),
+    intBytes(),
+    intBytes(),
+    byteByte(),
+    intBytes(),
+    bytesForInt(10),
+    inputBytes(),
+  );

package/src/fixtures/secp256k1.ts

@@ -0,0 +1,107 @@
+import {
+  Input,
+  MintOperation,
+  MintOutput,
+  OutputOwners,
+  TransferInput,
+  TransferOutput,
+} from '../serializable/fxs/secp256k1';
+import { Credential } from '../serializable/fxs/secp256k1/credential';
+import { OutputOwnersList } from '../serializable/fxs/secp256k1/outputOwnersList';
+import { Signature } from '../serializable/fxs/secp256k1/signature';
+import { concatBytes, hexToBuffer } from '../utils/buffer';
+import { addresses, addressesBytes } from './common';
+import {
+  bigIntPr,
+  bigIntPrBytes,
+  int,
+  intBytes,
+  ints,
+  intsBytes,
+} from './primitives';
+import { bytesForInt } from './utils/bytesFor';
+
+// https://docs.avax.network/specs/avm-transaction-serialization#secp256k1-mint-output-example
+export const mintOutputBytes = () => outputOwnerBytes();
+
+export const mintOutput = () => new MintOutput(outputOwner());
+
+// https://docs.avax.network/specs/avm-transaction-serialization#secp256k1-transfer-output
+export const transferOutputBytes = () =>
+  concatBytes(bigIntPrBytes(), outputOwnerBytes());
+
+export const transferOutput = () =>
+  new TransferOutput(bigIntPr(), outputOwner());
+
+export const outputOwnerBytes = () =>
+  concatBytes(
+    // locktime:
+    bigIntPrBytes(),
+    // threshold:
+    intBytes(),
+    addressesBytes(),
+  );
+
+export const outputOwner = () =>
+  new OutputOwners(bigIntPr(), int(), addresses()());
+
+export const inputBytes = () => intsBytes();
+
+export const input = () => new Input(ints());
+
+// https://docs.avax.network/specs/avm-transaction-serialization#secp256k1-transfer-input-example
+export const transferInputBytes = () =>
+  concatBytes(bigIntPrBytes(), inputBytes());
+
+export const transferInput = () => new TransferInput(bigIntPr(), input());
+
+// https://docs.avax.network/specs/avm-transaction-serialization#secp256k1-mint-operation-example
+export const mintOperationBytes = () =>
+  concatBytes(inputBytes(), mintOutputBytes(), transferOutputBytes());
+
+export const mintOperation = () =>
+  new MintOperation(input(), new MintOutput(outputOwner()), transferOutput());
+
+export const outputOwnersListBytes = () =>
+  concatBytes(bytesForInt(2), outputOwnerBytes(), outputOwnerBytes());
+
+export const outputOwnersList = () =>
+  new OutputOwnersList([outputOwner(), outputOwner()]);
+
+export const signatureBytes = () =>
+  new Uint8Array([
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
+    0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
+    0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1e, 0x1d, 0x1f, 0x20, 0x21, 0x22, 0x23,
+    0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2e, 0x2d, 0x2f,
+    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
+    0x3c, 0x3d, 0x3e, 0x3f, 0x00,
+  ]);
+
+export const signature2Bytes = () =>
+  new Uint8Array([
+    0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b,
+    0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
+    0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5e, 0x5d, 0x5f, 0x60, 0x61, 0x62, 0x63,
+    0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6e, 0x6d, 0x6f,
+    0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b,
+    0x7c, 0x7d, 0x7e, 0x7f, 0x00,
+  ]);
+
+export const signature = () =>
+  new Signature(
+    hexToBuffer(
+      '0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1e1d1f202122232425262728292a2b2c2e2d2f303132333435363738393a3b3c3d3e3f00',
+    ),
+  );
+
+export const signature2 = () =>
+  new Signature(
+    hexToBuffer(
+      '0x404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5e5d5f606162636465666768696a6b6c6e6d6f707172737475767778797a7b7c7d7e7f00',
+    ),
+  );
+
+export const credentialBytes = () =>
+  concatBytes(bytesForInt(2), signatureBytes(), signature2Bytes());
+export const credential = () => new Credential([signature(), signature2()]);

package/src/fixtures/transactions.ts

@@ -0,0 +1,192 @@
+import { Output } from '../serializable/evm';
+import {
+  BaseTx,
+  TransferableInput,
+  TransferableOutput,
+  UTXOID,
+} from '../serializable/avax';
+import { Utxo } from '../serializable/avax/utxo';
+import { Address, Id } from '../serializable/fxs/common';
+import {
+  OutputOwners,
+  TransferInput,
+  TransferOutput,
+} from '../serializable/fxs/secp256k1';
+import { BigIntPr, Int, Bytes } from '../serializable/primitives';
+import { StakeableLockIn, StakeableLockOut } from '../serializable/pvm';
+import { hexToBuffer } from '../utils';
+import { testContext } from './context';
+import { stringToBytes } from '@scure/base';
+
+export const cAddressForTest = '0xfd4DFC8f567caD8a275989982c5f8f1fC82B7563';
+export const privateKeyForTest =
+  '4ec512bf0130a604b68b80446238f20ccd94eec8588f56c5e5c499f1d0d7e7cd';
+export const xAddressForTest = 'X-fuji1w5jg0xyw2zq22nhpjar834gyeksc6wuleftqzg';
+export const pAddressForTest = 'P-fuji1w5jg0xyw2zq22nhpjar834gyeksc6wuleftqzg';
+export const cAddressBech32ForTest =
+  'C-fuji1w5jg0xyw2zq22nhpjar834gyeksc6wuleftqzg';
+
+export const testAvaxAssetID = Id.fromString(testContext.avaxAssetID);
+export const testOwnerXAddress = Address.fromString(xAddressForTest);
+export const testOwnerCBech32Address = Address.fromString(
+  cAddressBech32ForTest,
+);
+
+export const testUTXOID1 = Id.fromHex(
+  '0x009e71412d5b89d0b51e679a93cf59966c3c89346949f1976f930feddbfd765d',
+);
+export const testUTXOID2 = Id.fromHex(
+  '0xd1f6526c4233a5af42b0c8311a9824a84f73b3e32ba637aaa7d9dd4994bccbad',
+);
+export const testUTXOID3 = Id.fromHex(
+  '0x5199944d5f58272adff87558c5c0857d3de3be01da518431523bff2bbf1117e6',
+);
+export const testUTXOID4 = Id.fromHex(
+  '0x5199944d5f58272adff87558c5c0857d3de3be01da518431523bff2bbf1116e6',
+);
+
+export const testSubnetId =
+  '0x8c86d07cd60218661863e0116552dccd5bd84c564bd29d7181dbddd5ec616104';
+
+export const testVMId =
+  '0x61766d0000000000000000000000000000000000000000000000000000000000';
+
+export const testGenesisData = {
+  test: 'data',
+};
+
+export const testSubnetAuthData = new Bytes(
+  stringToBytes('utf8', '0x0000000a0000000100000000'),
+);
+
+export const getLockedUTXO = (
+  amt = new BigIntPr(BigInt(30 * 1e9)),
+  lockTime = BigInt(Math.floor(new Date().getTime() / 1000)) + 100000n,
+) =>
+  new Utxo(
+    new UTXOID(testUTXOID1, new Int(0)),
+    testAvaxAssetID,
+    new TransferOutput(
+      amt,
+      OutputOwners.fromNative([testOwnerXAddress.toBytes()], lockTime),
+    ),
+  );
+
+export const getNotTransferOutput = (amt = BigInt(30 * 1e9)) =>
+  new Utxo(
+    new UTXOID(testUTXOID2, new Int(0)),
+    testAvaxAssetID,
+    new StakeableLockIn(
+      new BigIntPr(2000000000n),
+      TransferableOutput.fromNative(testAvaxAssetID.toString(), amt, [
+        hexToBuffer('0x12345678901234578901234567890123457890'),
+      ]),
+    ),
+  );
+
+export const getStakeableLockoutOutput = (
+  id: Id,
+  amt: bigint,
+  lockTime: bigint = BigInt(Math.floor(new Date().getTime() / 1000)) + 100000n,
+  assetId = testAvaxAssetID,
+) =>
+  new Utxo(
+    new UTXOID(id, new Int(0)),
+    assetId,
+    new StakeableLockOut(
+      new BigIntPr(lockTime),
+      new TransferOutput(
+        new BigIntPr(amt),
+        OutputOwners.fromNative([testOwnerXAddress.toBytes()]),
+      ),
+    ),
+  );
+
+export const getTransferableInputForTest = (amt = 50000000000n) =>
+  TransferableInput.fromNative(
+    'cwMuSYz3XjaKNwwC7tDmzyWg2eNgpEtkeKwabZ4QJD9PDsjni',
+    0,
+    testContext.avaxAssetID,
+    amt,
+    [0],
+  );
+
+export const getStakeableLockedTransferableInputForTest = (
+  amtount: bigint,
+  lockTime: bigint,
+) =>
+  new TransferableInput(
+    new UTXOID(testUTXOID1, new Int(0)),
+    Id.fromString(testContext.avaxAssetID),
+    new StakeableLockIn(
+      new BigIntPr(lockTime),
+      TransferInput.fromNative(amtount, [0]),
+    ),
+  );
+
+export const getValidUtxo = (
+  amt = new BigIntPr(BigInt(50 * 1e9)),
+  assetId = testAvaxAssetID,
+) =>
+  new Utxo(
+    new UTXOID(testUTXOID3, new Int(0)),
+    assetId,
+    new TransferOutput(
+      amt,
+      OutputOwners.fromNative([testOwnerXAddress.toBytes()]),
+    ),
+  );
+
+export const fromAddressBytes = [testOwnerXAddress.toBytes()];
+
+export const getTransferableOutForTest = (
+  amount: bigint,
+  locktime?: bigint,
+  threshold?: number,
+) => {
+  return TransferableOutput.fromNative(
+    testContext.avaxAssetID,
+    amount,
+    fromAddressBytes,
+    locktime,
+    threshold,
+  );
+};
+
+export const getStakeableLockedTransferableOutForTest = (
+  amount: bigint,
+  lockTime: bigint,
+) => {
+  return new TransferableOutput(
+    Id.fromString(testContext.avaxAssetID),
+    new StakeableLockOut(
+      new BigIntPr(lockTime),
+      new TransferOutput(
+        new BigIntPr(amount),
+        OutputOwners.fromNative([testOwnerXAddress.toBytes()]),
+      ),
+    ),
+  );
+};
+
+export const testUtxos = () => [
+  getLockedUTXO(),
+  getNotTransferOutput(),
+  getValidUtxo(),
+];
+
+export const getBaseTxForTest = (changeAmount: bigint, blockchainId: string) =>
+  BaseTx.fromNative(
+    testContext.networkID,
+    blockchainId,
+    [getTransferableOutForTest(changeAmount)],
+    [getTransferableInputForTest()],
+    new Uint8Array(),
+  );
+
+export const getOutputForTest = () =>
+  new Output(
+    testOwnerXAddress,
+    new BigIntPr(BigInt(0.1 * 1e9)),
+    Id.fromString(testContext.avaxAssetID),
+  );

package/src/fixtures/utils/bytesFor.ts

@@ -0,0 +1,3 @@
+import { Int } from '../../serializable/primitives/int';
+
+export const bytesForInt = (num: number): Uint8Array => new Int(num).toBytes();

package/src/fixtures/utils/expectTx.ts

@@ -0,0 +1,5 @@
+export const expectTxs = (result: any, expected: any) => {
+  expect(JSON.stringify(result, null, 2)).toEqual(
+    JSON.stringify(expected, null, 2),
+  );
+};

package/src/fixtures/utils/makeList.spec.ts

@@ -0,0 +1,16 @@
+import { concatBytes } from '../../utils/buffer';
+import { address, addressBytes } from '../common';
+import { bytesForInt } from './bytesFor';
+import { makeList, makeListBytes } from './makeList';
+
+describe('makeList', () => {
+  it('make lists', () => {
+    expect(makeList(address)()).toEqual([address(), address()]);
+  });
+
+  it('make lists bytes', () => {
+    expect(makeListBytes(addressBytes)()).toEqual(
+      concatBytes(bytesForInt(2), addressBytes(), addressBytes()),
+    );
+  });
+});

package/src/fixtures/utils/makeList.ts

@@ -0,0 +1,11 @@
+import { concatBytes } from '../../utils/buffer';
+import type { Serializable } from '../../serializable/common/types';
+import { bytesForInt } from './bytesFor';
+
+export const makeList =
+  <T extends Serializable>(single: () => T) =>
+  (): T[] =>
+    [single(), single()];
+
+export const makeListBytes = (single: () => Uint8Array) => () =>
+  concatBytes(bytesForInt(2), single(), single());