@bitgo-forks/avalanchejs 4.1.0-alpha.1

package/src/constants/zeroValue.ts

@@ -0,0 +1,18 @@
+import { Id } from '../serializable/fxs/common';
+import { OutputOwners } from '../serializable/fxs/secp256k1';
+import {
+  SepkSignatureLength,
+  Signature,
+} from '../serializable/fxs/secp256k1/signature';
+import { BigIntPr, Int } from '../serializable/primitives';
+
+export const zeroOutputOwners = new OutputOwners(
+  new BigIntPr(0n),
+  new Int(0),
+  [],
+);
+
+export const emptyId = new Id(new Uint8Array(32));
+export const emptySignature = new Signature(
+  new Uint8Array(Array(SepkSignatureLength).fill(0)),
+);

package/src/crypto/bls.spec.ts

@@ -0,0 +1,60 @@
+import { stringToBytes } from '@scure/base';
+import { hexToBuffer } from '../utils/buffer';
+import * as bls from './bls';
+
+const msg = stringToBytes('utf8', 'test');
+const skStr =
+  '233428aaadf8a5d11ebba263d97b85a286750540f4abd04f109321e07b746277';
+const pkStr =
+  'adf6062df01fc18456140f7126567a84834d85b2af70454a7aacad932b92d0d7d0dab897d2f9bf46021511969f5b62f8';
+const popStr =
+  '98e8d8e33a51ecdcbcca2166370d99fdc02134e8e84ca34327cd2ec4412eb3b39619050a0146cba5d5948cb43c32a7f00f5df841700e3937d58b64e6f74493891b2a70402111841f69e9fc73236beb79f2e63e9a7caa55b724c61a139969ff57';
+const sigStr =
+  '9254acb2bfe4638daef4424b07f7a03987245c8945e634a7fca3302a2bb45e0aa9d2f8f5198e37d41aa65f8ab81efa4608d23ab55ccf06122f9718b37d42e0274297966191e3de2852f3a328727fe0dcced453c943405205b0f23038b7409e66';
+
+describe('bls', () => {
+  it('serializes correctly', async () => {
+    const sk = bls.secretKeyFromBytes(skStr);
+    expect(bls.secretKeyToBytes(sk)).toEqual(hexToBuffer(skStr));
+
+    const pk = bls.publicKeyFromBytes(pkStr);
+    expect(bls.publicKeyToBytes(pk)).toEqual(hexToBuffer(pkStr));
+
+    const pk2 = bls.publicKeyFromBytes(hexToBuffer(pkStr));
+    expect(bls.publicKeyToBytes(pk2)).toEqual(hexToBuffer(pkStr));
+
+    const pop = bls.signatureFromBytes(hexToBuffer(popStr));
+    expect(bls.signatureToBytes(pop)).toEqual(hexToBuffer(popStr));
+
+    const sig = bls.signatureFromBytes(hexToBuffer(sigStr));
+    expect(bls.signatureToBytes(sig)).toEqual(hexToBuffer(sigStr));
+  });
+
+  it('generates signature correctly', async () => {
+    const sk = bls.secretKeyFromBytes(skStr);
+    expect(bls.sign(msg, sk)).toEqual(hexToBuffer(sigStr));
+  });
+
+  it('verifies signature correctly', async () => {
+    const pk = bls.publicKeyFromBytes(pkStr);
+    const sig = bls.signatureFromBytes(hexToBuffer(sigStr));
+
+    expect(bls.verify(pk, sig, msg)).toEqual(true);
+  });
+
+  it('generates proof of possession correctly', async () => {
+    const sk = bls.secretKeyFromBytes(skStr);
+    const pk = bls.publicKeyFromBytes(pkStr);
+    const pkBytes = bls.publicKeyToBytes(pk);
+
+    expect(bls.signProofOfPossession(pkBytes, sk)).toEqual(hexToBuffer(popStr));
+  });
+
+  it('verifies proof of possession correctly', async () => {
+    const pk = bls.publicKeyFromBytes(pkStr);
+    const pop = bls.signatureFromBytes(hexToBuffer(popStr));
+    const pkBytes = bls.publicKeyToBytes(pk);
+
+    expect(bls.verifyProofOfPossession(pk, pop, pkBytes)).toEqual(true);
+  });
+});

package/src/crypto/bls.ts

@@ -0,0 +1,77 @@
+import { bls12_381 } from '@noble/curves/bls12-381';
+import type { ProjPointType } from '@noble/curves/abstract/weierstrass';
+import { hexToBuffer } from '../utils/buffer';
+
+export type PublicKey = ProjPointType<bigint>;
+export type SecretKey = bigint;
+export type Signature = ProjPointType<typeof bls12_381.fields.Fp2.ZERO>;
+export type Message = ProjPointType<typeof bls12_381.fields.Fp2.ZERO>;
+
+export const PUBLIC_KEY_LENGTH = 48;
+export const SIGNATURE_LENGTH = 96;
+
+const signatureDST = 'BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_POP_';
+const proofOfPossessionDST = 'BLS_POP_BLS12381G2_XMD:SHA-256_SSWU_RO_POP_';
+
+export function secretKeyFromBytes(skBytes: Uint8Array | string): SecretKey {
+  return bls12_381.G1.normPrivateKeyToScalar(skBytes);
+}
+
+export function secretKeyToBytes(sk: SecretKey): Uint8Array {
+  return hexToBuffer(sk.toString(16));
+}
+
+export function publicKeyFromBytes(pkBytes: Uint8Array | string): PublicKey {
+  return bls12_381.G1.ProjectivePoint.fromHex(pkBytes);
+}
+
+export function publicKeyToBytes(pk: PublicKey): Uint8Array {
+  return pk.toRawBytes();
+}
+
+export function signatureFromBytes(sigBytes: Uint8Array): Signature {
+  return bls12_381.Signature.fromHex(sigBytes);
+}
+
+export function signatureToBytes(sig: Signature): Uint8Array {
+  return sig.toRawBytes();
+}
+
+export function verify(
+  pk: PublicKey,
+  sig: Signature,
+  msg: Uint8Array | string | Message,
+): boolean {
+  return bls12_381.verify(sig, msg, pk, {
+    DST: signatureDST,
+  });
+}
+
+export function verifyProofOfPossession(
+  pk: PublicKey,
+  sig: Signature,
+  msg: Uint8Array | string | Message,
+): boolean {
+  return bls12_381.verify(sig, msg, pk, {
+    DST: proofOfPossessionDST,
+  });
+}
+
+export function sign(msg: Uint8Array | string, sk: SecretKey): Uint8Array {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error Will error until a version of @noble/curves is released with https://github.com/paulmillr/noble-curves/pull/117
+  return bls12_381.sign(msg, sk, {
+    DST: signatureDST,
+  });
+}
+
+export function signProofOfPossession(
+  msg: Uint8Array | string,
+  sk: SecretKey,
+): Uint8Array {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error Will error until a version of @noble/curves is released with https://github.com/paulmillr/noble-curves/pull/117
+  return bls12_381.sign(msg, sk, {
+    DST: proofOfPossessionDST,
+  });
+}

package/src/crypto/index.ts

@@ -0,0 +1,2 @@
+export * as secp256k1 from './secp256k1';
+export * as bls from './bls';

package/src/crypto/secp256k1.spec.ts

@@ -0,0 +1,76 @@
+import { sha256 } from '@noble/hashes/sha256';
+import { base58check } from '../utils/base58';
+import { bufferToHex, hexToBuffer } from '../utils/buffer';
+import * as secp256k1 from './secp256k1';
+
+describe('secp256k1', function () {
+  it('works correctly', async () => {
+    const key = '24jUJ9vZexUM6expyMcT48LBx27k1m7xpraoV62oSQAHdziao5';
+    const privKey = base58check.decode(key);
+    const pubKey = secp256k1.getPublicKey(privKey);
+
+    expect(
+      base58check.encode(secp256k1.publicKeyBytesToAddress(pubKey)),
+    ).toEqual('Q4MzFZZDPHRPAHFeDs3NiyyaZDvxHKivf');
+
+    const tests = [
+      {
+        msg: 'hello world',
+        sig: new Uint8Array([
+          0x17, 0x8c, 0xb6, 0x09, 0x6b, 0x3c, 0xa5, 0x82, 0x0a, 0x4c, 0x6e,
+          0xce, 0xdf, 0x15, 0xb6, 0x8b, 0x6f, 0x50, 0xe2, 0x52, 0xc2, 0xb6,
+          0x4f, 0x37, 0x74, 0x88, 0x86, 0x02, 0xcc, 0x9f, 0xa0, 0x8c, 0x5d,
+          0x01, 0x9d, 0x82, 0xfd, 0xde, 0x95, 0xfd, 0xf2, 0x34, 0xaa, 0x2d,
+          0x12, 0xad, 0x79, 0xb5, 0xab, 0xb3, 0x45, 0xfe, 0x95, 0x3a, 0x9f,
+          0x72, 0xf7, 0x09, 0x14, 0xfd, 0x31, 0x39, 0x06, 0x3b, 0x00,
+        ]),
+      },
+      {
+        msg: 'scooby doo',
+        sig: new Uint8Array([
+          0xc2, 0x57, 0x3f, 0x29, 0xb0, 0xd1, 0x7a, 0xe7, 0x00, 0x9a, 0x9f,
+          0x17, 0xa4, 0x55, 0x8d, 0x32, 0x46, 0x2e, 0x5b, 0x8d, 0x05, 0x9e,
+          0x38, 0x32, 0xec, 0xb0, 0x32, 0x54, 0x1a, 0xbc, 0x7d, 0xaf, 0x57,
+          0x51, 0xf9, 0x6b, 0x85, 0x71, 0xbc, 0xb7, 0x18, 0xd2, 0x6b, 0xe8,
+          0xed, 0x8d, 0x59, 0xb0, 0xd6, 0x03, 0x69, 0xab, 0x57, 0xac, 0xc0,
+          0xf7, 0x13, 0x3b, 0x21, 0x94, 0x56, 0x03, 0x8e, 0xc7, 0x01,
+        ]),
+      },
+      {
+        msg: 'a really long string',
+        sig: new Uint8Array([
+          0x1b, 0xf5, 0x61, 0xc3, 0x60, 0x07, 0xd2, 0xa6, 0x12, 0x68, 0xe9,
+          0xe1, 0x3a, 0x90, 0x2a, 0x9c, 0x2b, 0xa4, 0x3e, 0x28, 0xf8, 0xd4,
+          0x75, 0x54, 0x21, 0x57, 0x11, 0xdc, 0xdc, 0xc6, 0xd3, 0x5e, 0x78,
+          0x43, 0x18, 0xf6, 0x22, 0x91, 0x37, 0x3c, 0x95, 0x77, 0x9f, 0x67,
+          0x94, 0x91, 0x0a, 0x44, 0x16, 0xbf, 0xa3, 0xae, 0x9f, 0x25, 0xfa,
+          0x34, 0xa0, 0x14, 0xea, 0x9c, 0x6f, 0xe0, 0x20, 0x37, 0x00,
+        ]),
+      },
+    ];
+
+    for (const test of tests) {
+      const hash = sha256(test.msg);
+
+      await expect(secp256k1.sign(test.msg, privKey)).resolves.toEqual(
+        test.sig,
+      );
+      await expect(secp256k1.signHash(hash, privKey)).resolves.toEqual(
+        test.sig,
+      );
+      expect(secp256k1.recoverPublicKey(hash, test.sig)).toEqual(pubKey);
+      expect(secp256k1.verify(test.sig, hash, pubKey)).toEqual(true);
+    }
+  });
+
+  it('works with EVM', () => {
+    const publicKey = hexToBuffer(
+      '04e68acfc0253a10620dff706b0a1b1f1f5833ea3beb3bde2250d5f271f3563606672ebc45e0b7ea2e816ecb70ca03137b1c9476eec63d4632e990020b7b6fba39',
+    );
+
+    const ethAddrKey = bufferToHex(secp256k1.publicKeyToEthAddress(publicKey));
+    expect(ethAddrKey).toBe(
+      '0x90F8bf6A479f320ead074411a4B0e7944Ea8c9C1'.toLocaleLowerCase(),
+    );
+  });
+});

package/src/crypto/secp256k1.ts

@@ -0,0 +1,53 @@
+import { ripemd160 } from '@noble/hashes/ripemd160';
+import { sha256 } from '@noble/hashes/sha256';
+import * as secp from '@noble/curves/secp256k1';
+import { Address } from 'micro-eth-signer';
+import { concatBytes, hexToBuffer } from '../utils/buffer';
+
+export function randomPrivateKey() {
+  return secp.secp256k1.utils.randomPrivateKey();
+}
+
+export function sign(msg: Uint8Array | string, privKey: Uint8Array) {
+  return signHash(sha256(msg), privKey);
+}
+
+export async function signHash(hash: Uint8Array, privKey: Uint8Array) {
+  const sig = await secp.secp256k1.sign(hash, privKey);
+
+  if (sig.recovery !== undefined) {
+    return concatBytes(sig.toCompactRawBytes(), new Uint8Array([sig.recovery]));
+  } else {
+    throw new Error(`Recovery bit is missing.`);
+  }
+}
+
+export function recoverPublicKey(hash: Uint8Array | string, sig: Uint8Array) {
+  const recoveryBit = sig.slice(-1);
+  const secpSig = secp.secp256k1.Signature.fromCompact(
+    sig.slice(0, -1),
+  ).addRecoveryBit(recoveryBit[0]);
+  const point = secpSig.recoverPublicKey(hash);
+
+  return point.toRawBytes(true);
+}
+
+export function getPublicKey(privKey: Uint8Array) {
+  return secp.secp256k1.getPublicKey(privKey, true);
+}
+
+export function verify(
+  sig: Uint8Array,
+  hash: Uint8Array | string,
+  publicKey: Uint8Array,
+) {
+  return secp.secp256k1.verify(sig.slice(0, -1), hash, publicKey);
+}
+
+export function publicKeyBytesToAddress(publicKey: Uint8Array) {
+  return ripemd160(sha256(publicKey));
+}
+
+export function publicKeyToEthAddress(key: Uint8Array) {
+  return hexToBuffer(Address.fromPublicKey(key));
+}

package/src/fixtures/avax.ts

@@ -0,0 +1,176 @@
+import {
+  BaseTx as AvaxBaseTx,
+  TransferableInput,
+  TransferableOutput,
+} from '../serializable/avax';
+import { UTXOID } from '../serializable/avax/utxoId';
+import { TransferableOp } from '../serializable/avax/transferableOp';
+import { Utxo } from '../serializable/avax/utxo';
+import { CreateAssetTx } from '../serializable/avm/createAssetTx';
+import { ExportTx } from '../serializable/avm/exportTx';
+import { ImportTx } from '../serializable/avm/importTx';
+import { BaseTx as AvmBaseTx } from '../serializable/avm/baseTx';
+import { BaseTx as PvmBaseTx } from '../serializable/pvm/baseTx';
+import { InitialState } from '../serializable/avm/initialState';
+import { OperationTx } from '../serializable/avm/operationTx';
+import { SignedTx } from '../serializable/avax/signedTx';
+import { Byte, Int, Short } from '../serializable/primitives';
+import { concatBytes } from '../utils/buffer';
+import { id, idBytes } from './common';
+import { mintOperation, mintOperationBytes } from './nft';
+import {
+  bytes,
+  bytesBytes,
+  int,
+  intBytes,
+  stringPr,
+  stringPrBytes,
+} from './primitives';
+import {
+  credential,
+  credentialBytes,
+  mintOutput,
+  mintOutputBytes,
+  transferInput,
+  transferInputBytes,
+  transferOutput,
+  transferOutputBytes,
+} from './secp256k1';
+import { bytesForInt } from './utils/bytesFor';
+import { makeList, makeListBytes } from './utils/makeList';
+
+// https://docs.avax.network/specs/avm-transaction-serialization#transferable-output-example
+export const transferableOutputBytes = () =>
+  concatBytes(idBytes(), bytesForInt(7), transferOutputBytes());
+
+export const transferableOutput = () =>
+  new TransferableOutput(id(), transferOutput());
+
+export const transferableOutputs = makeList(transferableOutput);
+
+export const transferableOutputsBytes = makeListBytes(transferableOutputBytes);
+
+// https://docs.avax.network/specs/avm-transaction-serialization#transferable-input-example
+export const transferableInputBytes = () =>
+  concatBytes(utxoIdBytes(), idBytes(), bytesForInt(5), transferInputBytes());
+
+export const transferableInput = () =>
+  new TransferableInput(utxoId(), id(), transferInput());
+
+export const transferableInputsBytes = makeListBytes(transferableInputBytes);
+export const transferableInputs = makeList(transferableInput);
+
+export const transferableOp = () =>
+  new TransferableOp(id(), makeList(utxoId)(), mintOperation());
+export const transferableOpBytes = () =>
+  concatBytes(
+    idBytes(),
+    makeListBytes(utxoIdBytes)(),
+    bytesForInt(12),
+    mintOperationBytes(),
+  );
+
+export const utxoIdBytes = () => concatBytes(idBytes(), bytesForInt(5));
+
+export const utxoId = () => new UTXOID(id(), new Int(5));
+
+export const baseTx = () =>
+  new AvaxBaseTx(
+    int(),
+    id(),
+    transferableOutputs(),
+    transferableInputs(),
+    bytes(),
+  );
+
+export const baseTxbytes = () =>
+  concatBytes(
+    intBytes(),
+    idBytes(),
+    transferableOutputsBytes(),
+    transferableInputsBytes(),
+    bytesBytes(),
+  );
+
+export const initialStateBytes = () =>
+  concatBytes(
+    intBytes(),
+    bytesForInt(2),
+    bytesForInt(5),
+    transferInputBytes(),
+    bytesForInt(6),
+    mintOutputBytes(),
+  );
+
+export const initialState = () =>
+  new InitialState(int(), [transferInput(), mintOutput()]);
+
+export const createAssetTxBytes = () =>
+  concatBytes(
+    baseTxbytes(),
+    stringPrBytes(),
+    stringPrBytes(),
+    new Uint8Array([0x0f]),
+    makeListBytes(initialStateBytes)(),
+  );
+export const createAssetTx = () =>
+  new CreateAssetTx(
+    baseTx(),
+    stringPr(),
+    stringPr(),
+    new Byte(new Uint8Array([0x0f])),
+    makeList(initialState)(),
+  );
+
+export const operationTx = () =>
+  new OperationTx(baseTx(), makeList(transferableOp)());
+
+export const operationTxBytes = () =>
+  concatBytes(baseTxbytes(), makeListBytes(transferableOpBytes)());
+
+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 avmBaseTx = () => new AvmBaseTx(baseTx());
+
+export const avmBaseTxBytes = () => baseTxbytes();
+
+export const pvmBaseTx = () => new PvmBaseTx(baseTx());
+
+export const pvmBaseTxBytes = () => baseTxbytes();
+
+export const signedTx = () =>
+  new SignedTx(exportTx(), [credential(), credential()]);
+
+export const signedTxBytes = () =>
+  concatBytes(
+    new Short(0).toBytes(),
+    bytesForInt(4),
+    exportTxBytes(),
+    bytesForInt(2),
+    bytesForInt(9),
+    credentialBytes(),
+    bytesForInt(9),
+    credentialBytes(),
+  );
+
+export const utxo = () => new Utxo(utxoId(), id(), transferOutput());
+export const utxoBytes = () =>
+  concatBytes(utxoIdBytes(), idBytes(), bytesForInt(7), transferOutputBytes());

package/src/fixtures/codec.ts

@@ -0,0 +1,15 @@
+import { getAVMManager } from '../serializable/avm/codec';
+import { codec as EVMCodec } from '../serializable/evm/codec';
+import { Short } from '../serializable/primitives';
+import { codec } from '../serializable/pvm/codec';
+
+// Check for circular imports in the fx type
+// registries if tests are throwing errors
+
+export const testManager = getAVMManager;
+
+export const testCodec = () => testManager().getCodecForVersion(new Short(0));
+
+export const testPVMCodec = () => codec;
+
+export const testEVMCodec = () => EVMCodec;

package/src/fixtures/common.ts

@@ -0,0 +1,45 @@
+import { Address } from '../serializable/fxs/common/address';
+import { Id } from '../serializable/fxs/common/id';
+import { NodeId } from '../serializable/fxs/common/nodeId';
+import { bytesForInt } from './utils/bytesFor';
+import { makeList } from './utils/makeList';
+
+const TEST_ADDRESS_HEX = '8db97c7cece249c2b98bdc0226cc4c2a57bf52fc';
+const TEST_ID_HEX =
+  'dbcf890f77f49b96857648b72b77f9f82937f28a68704af05da0dc12ba53f2db';
+const TEST_NODE_ID_HEX = '0xe9094f73698002fd52c90819b457b9fbc866ab80';
+
+export const addressBytes = () =>
+  new Uint8Array([
+    0x8d, 0xb9, 0x7c, 0x7c, 0xec, 0xe2, 0x49, 0xc2, 0xb9, 0x8b, 0xdc, 0x02,
+    0x26, 0xcc, 0x4c, 0x2a, 0x57, 0xbf, 0x52, 0xfc,
+  ]);
+
+export const address = () => Address.fromHex(TEST_ADDRESS_HEX);
+
+export const idBytes = () =>
+  new Uint8Array([
+    0xdb, 0xcf, 0x89, 0x0f, 0x77, 0xf4, 0x9b, 0x96, 0x85, 0x76, 0x48, 0xb7,
+    0x2b, 0x77, 0xf9, 0xf8, 0x29, 0x37, 0xf2, 0x8a, 0x68, 0x70, 0x4a, 0xf0,
+    0x5d, 0xa0, 0xdc, 0x12, 0xba, 0x53, 0xf2, 0xdb,
+  ]);
+
+export const id = () => Id.fromHex(TEST_ID_HEX);
+
+export const nodeIdBytes = () =>
+  new Uint8Array([
+    0xe9, 0x09, 0x4f, 0x73, 0x69, 0x80, 0x02, 0xfd, 0x52, 0xc9, 0x08, 0x19,
+    0xb4, 0x57, 0xb9, 0xfb, 0xc8, 0x66, 0xab, 0x80,
+  ]);
+
+export const nodeId = () => NodeId.fromHex(TEST_NODE_ID_HEX);
+
+export const addressesBytes = () =>
+  new Uint8Array([
+    //length
+    ...bytesForInt(2),
+    ...addressBytes(),
+    ...addressBytes(),
+  ]);
+
+export const addresses = () => makeList(address);

package/src/fixtures/context.ts

@@ -0,0 +1,19 @@
+import type { Context } from '../vms/context';
+
+export const testContext: Context = {
+  xBlockchainID: '2oYMBNV4eNHyqk2fjjV5nVQLDbtmNJzq5s3qs3Lo6ftnC6FByM',
+  pBlockchainID: '11111111111111111111111111111111LpoYY',
+  cBlockchainID: '2q9e4r6Mu3U68nU1fYjgbR6JvwrRx36CohpAX5UQxse55x1Q5',
+  avaxAssetID: 'FvwEAhmxKfeiG8SnEvq42hc6whRyY3EFYAvebMqDNDGCgxN5Z',
+  baseTxFee: 1000000n,
+  createAssetTxFee: 10000000n,
+  createSubnetTxFee: 1000000000n,
+  transformSubnetTxFee: 10000000000n,
+  createBlockchainTxFee: 1000000000n,
+  addPrimaryNetworkValidatorFee: 0n,
+  addPrimaryNetworkDelegatorFee: 0n,
+  addSubnetValidatorFee: 1000000n,
+  addSubnetDelegatorFee: 1000000n,
+  networkID: 1,
+  hrp: 'avax',
+};

package/src/fixtures/evm.ts

@@ -0,0 +1,58 @@
+import { concatBytes } from '@noble/hashes/utils';
+import { ExportTx } from '../serializable/evm/exportTx';
+import { ImportTx } from '../serializable/evm/importTx';
+import { Input } from '../serializable/evm/input';
+import { Output } from '../serializable/evm/output';
+import {
+  transferableInput,
+  transferableInputBytes,
+  transferableOutput,
+  transferableOutputBytes,
+} from './avax';
+import { address, addressBytes, id, idBytes } from './common';
+import { bigIntPr, bigIntPrBytes, int, intBytes } from './primitives';
+import { makeList, makeListBytes } from './utils/makeList';
+
+export const output = () => new Output(address(), bigIntPr(), id());
+export const outputBytes = () =>
+  concatBytes(addressBytes(), bigIntPrBytes(), idBytes());
+
+export const importTx = () =>
+  new ImportTx(
+    int(),
+    id(),
+    id(),
+    makeList(transferableInput)(),
+    makeList(output)(),
+  );
+
+export const importTxBytes = () =>
+  concatBytes(
+    intBytes(),
+    idBytes(),
+    idBytes(),
+    makeListBytes(transferableInputBytes)(),
+    makeListBytes(outputBytes)(),
+  );
+
+export const input = () => new Input(address(), bigIntPr(), id(), bigIntPr());
+export const inputBytes = () =>
+  concatBytes(addressBytes(), bigIntPrBytes(), idBytes(), bigIntPrBytes());
+
+export const exportTx = () =>
+  new ExportTx(
+    int(),
+    id(),
+    id(),
+    makeList(input)(),
+    makeList(transferableOutput)(),
+  );
+
+export const exportTxBytes = () =>
+  concatBytes(
+    intBytes(),
+    idBytes(),
+    idBytes(),
+    makeListBytes(inputBytes)(),
+    makeListBytes(transferableOutputBytes)(),
+  );

package/src/fixtures/nft.ts

@@ -0,0 +1,40 @@
+import {
+  MintOperation,
+  MintOutput,
+  TransferOutput,
+} from '../serializable/fxs/nft';
+import { bytes, bytesBytes, int, intBytes } from './primitives';
+import { TransferOperation } from '../serializable/fxs/nft/transferOperation';
+import { concatBytes } from '../utils/buffer';
+import {
+  input,
+  inputBytes,
+  outputOwner,
+  outputOwnerBytes,
+  outputOwnersList,
+  outputOwnersListBytes,
+} from './secp256k1';
+
+// https://docs.avax.network/specs/avm-transaction-serialization/#nft-mint-output-example
+export const mintOutputBytes = () =>
+  concatBytes(intBytes(), outputOwnerBytes());
+
+export const mintOutput = () => new MintOutput(int(), outputOwner());
+
+// https://docs.avax.network/specs/avm-transaction-serialization/#nft-transfer-output-example
+export const transferOutputBytes = () =>
+  concatBytes(intBytes(), bytesBytes(), outputOwnerBytes());
+
+export const transferOutput = () =>
+  new TransferOutput(int(), bytes(), outputOwner());
+
+export const mintOperationBytes = () =>
+  concatBytes(inputBytes(), intBytes(), bytesBytes(), outputOwnersListBytes());
+export const mintOperation = () =>
+  new MintOperation(input(), int(), bytes(), outputOwnersList());
+
+export const transferOperationBytes = () =>
+  concatBytes(inputBytes(), transferOutputBytes());
+
+export const transferOperation = () =>
+  new TransferOperation(input(), transferOutput());