@bitgo-forks/avalanchejs 4.1.0-alpha.1

package/src/serializable/avm/initialState.spec.ts

@@ -0,0 +1,10 @@
+import { initialState, initialStateBytes } from '../../fixtures/avax';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { InitialState } from './initialState';
+
+testSerialization(
+  'InitialState',
+  InitialState,
+  initialState,
+  initialStateBytes,
+);

package/src/serializable/avm/initialState.ts

@@ -0,0 +1,33 @@
+import { concatBytes } from '../../utils/buffer';
+import type { Codec } from '../codec/codec';
+import type { Serializable } from '../common/types';
+import { serializable } from '../common/types';
+import { Int } from '../primitives';
+import { unpackCodecList } from '../../utils/serializeList';
+import { unpack } from '../../utils/struct';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://docs.avax.network/specs/avm-transaction-serialization#initial-state
+ */
+@serializable()
+export class InitialState {
+  _type = TypeSymbols.InitialState;
+
+  constructor(
+    private readonly fxId: Int,
+    private readonly outputs: Serializable[],
+  ) {}
+
+  static fromBytes(
+    bytes: Uint8Array,
+    codec: Codec,
+  ): [InitialState, Uint8Array] {
+    const [fxId, outputs, rest] = unpack(bytes, [Int, unpackCodecList], codec);
+    return [new InitialState(fxId, outputs), rest];
+  }
+
+  toBytes(codec: Codec) {
+    return concatBytes(this.fxId.toBytes(), codec.PackPrefixList(this.outputs));
+  }
+}

package/src/serializable/avm/operationTx.spec.ts

@@ -0,0 +1,5 @@
+import { operationTx, operationTxBytes } from '../../fixtures/avax';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { OperationTx } from './operationTx';
+
+testSerialization('OperationTx', OperationTx, operationTx, operationTxBytes);

package/src/serializable/avm/operationTx.ts

@@ -0,0 +1,34 @@
+import { concatBytes } from '../../utils/buffer';
+import { packList, toListStruct } from '../../utils/serializeList';
+import { unpack } from '../../utils/struct';
+import { BaseTx } from '../avax/baseTx';
+import { TransferableOp } from '../avax/transferableOp';
+import type { Codec } from '../codec/codec';
+import { serializable } from '../common/types';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://docs.avax.network/specs/avm-transaction-serialization#unsigned-OperationTx
+ */
+@serializable()
+export class OperationTx {
+  _type = TypeSymbols.OperationTx;
+
+  constructor(
+    private readonly baseTx: BaseTx,
+    private readonly ops: TransferableOp[],
+  ) {}
+
+  static fromBytes(bytes: Uint8Array, codec: Codec): [OperationTx, Uint8Array] {
+    const [baseTx, ops, remaining] = unpack(
+      bytes,
+      [BaseTx, toListStruct(TransferableOp)],
+      codec,
+    );
+    return [new OperationTx(baseTx, ops), remaining];
+  }
+
+  toBytes(codec: Codec) {
+    return concatBytes(this.baseTx.toBytes(codec), packList(this.ops, codec));
+  }
+}

package/src/serializable/avm/typeGuards.spec.ts

@@ -0,0 +1,63 @@
+import {
+  isAvmBaseTx,
+  isExportTx,
+  isImportTx,
+  isOperationTx,
+  isCreateAssetTx,
+} from './typeGuards';
+import { TypeSymbols } from '../constants';
+import type { Serializable } from '../common/types';
+import { onlyChecksOneGuard } from '../../fixtures/utils/typeguards';
+
+const typeGuards = [
+  isAvmBaseTx,
+  isExportTx,
+  isImportTx,
+  isOperationTx,
+  isCreateAssetTx,
+];
+
+describe('avm/typeGuards', function () {
+  it('can check base tx', () => {
+    const tx = { _type: TypeSymbols.AvmBaseTx } as Serializable;
+    const check = isAvmBaseTx(tx);
+    expect(check).toBe(true);
+    expect(onlyChecksOneGuard(tx, typeGuards)).toBe(true);
+  });
+
+  it('can check export tx', () => {
+    const tx = {
+      _type: TypeSymbols.AvmExportTx,
+    } as Serializable;
+    const check = isExportTx(tx);
+    expect(check).toBe(true);
+    expect(onlyChecksOneGuard(tx, typeGuards)).toBe(true);
+  });
+
+  it('can check import tx', () => {
+    const tx = {
+      _type: TypeSymbols.AvmImportTx,
+    } as Serializable;
+    const check = isImportTx(tx);
+    expect(check).toBe(true);
+    expect(onlyChecksOneGuard(tx, typeGuards)).toBe(true);
+  });
+
+  it('can check operation tx', () => {
+    const tx = {
+      _type: TypeSymbols.OperationTx,
+    } as Serializable;
+    const check = isOperationTx(tx);
+    expect(check).toBe(true);
+    expect(onlyChecksOneGuard(tx, typeGuards)).toBe(true);
+  });
+
+  it('can check create asset tx', () => {
+    const tx = {
+      _type: TypeSymbols.CreateAssetTx,
+    } as Serializable;
+    const check = isCreateAssetTx(tx);
+    expect(check).toBe(true);
+    expect(onlyChecksOneGuard(tx, typeGuards)).toBe(true);
+  });
+});

package/src/serializable/avm/typeGuards.ts

@@ -0,0 +1,27 @@
+import type { Serializable } from '../common/types';
+import type { BaseTx } from './baseTx';
+import type { CreateAssetTx } from './createAssetTx';
+import type { ExportTx } from './exportTx';
+import type { ImportTx } from './importTx';
+import type { OperationTx } from './operationTx';
+import { TypeSymbols } from '../constants';
+
+export function isAvmBaseTx(tx: Serializable): tx is BaseTx {
+  return tx._type === TypeSymbols.AvmBaseTx;
+}
+
+export function isExportTx(tx: Serializable): tx is ExportTx {
+  return tx._type === TypeSymbols.AvmExportTx;
+}
+
+export function isImportTx(tx: Serializable): tx is ImportTx {
+  return tx._type === TypeSymbols.AvmImportTx;
+}
+
+export function isCreateAssetTx(tx: Serializable): tx is CreateAssetTx {
+  return tx._type === TypeSymbols.CreateAssetTx;
+}
+
+export function isOperationTx(tx: Serializable): tx is OperationTx {
+  return tx._type === TypeSymbols.OperationTx;
+}

package/src/serializable/codec/codec.spec.ts

@@ -0,0 +1,67 @@
+import { Codec } from '.';
+import { id, idBytes } from '../../fixtures/common';
+import {
+  mintOutput,
+  mintOutputBytes,
+  outputOwner,
+  outputOwnerBytes,
+} from '../../fixtures/secp256k1';
+import { bytesForInt } from '../../fixtures/utils/bytesFor';
+import { Id } from '../fxs/common';
+import { MintOutput, OutputOwners } from '../fxs/secp256k1';
+import { concatBytes } from '../../utils/buffer';
+import { unpack } from '../../utils/struct';
+
+describe('Codec', () => {
+  let testCodec: Codec;
+  beforeEach(() => {
+    testCodec = new Codec([MintOutput, OutputOwners]);
+  });
+
+  it('unpacks types correctly', () => {
+    const bytes = concatBytes(bytesForInt(1), outputOwnerBytes());
+
+    const [out, remainder] = testCodec.UnpackPrefix(bytes);
+
+    expect(out).toStrictEqual(outputOwner());
+
+    expect(remainder).toStrictEqual(new Uint8Array());
+  });
+
+  it('packs types correctly', () => {
+    const owners = outputOwner();
+    const bytes = concatBytes(bytesForInt(1), outputOwnerBytes());
+
+    expect(testCodec.PackPrefix(owners)).toStrictEqual(bytes);
+  });
+
+  it('packs list of types correctly', () => {
+    const input = [outputOwner(), mintOutput()];
+    const output = testCodec.PackPrefixList(input);
+
+    expect(output).toEqual(
+      concatBytes(
+        bytesForInt(2),
+        bytesForInt(1),
+        outputOwnerBytes(),
+        bytesForInt(0),
+        mintOutputBytes(),
+      ),
+    );
+  });
+
+  it('packs types correctly', () => {
+    const owners = outputOwner();
+    const bytes = concatBytes(bytesForInt(1), outputOwnerBytes());
+
+    expect(testCodec.PackPrefix(owners)).toStrictEqual(bytes);
+  });
+
+  it('works with unpack', () => {
+    const input = concatBytes(idBytes(), bytesForInt(1), outputOwnerBytes());
+    const [idoutput, owner, remaining] = unpack(input, [Id, Codec], testCodec);
+    expect(idoutput).toEqual(id());
+    expect(owner).toEqual(outputOwner());
+    expect(remaining).toStrictEqual(new Uint8Array());
+  });
+});

package/src/serializable/codec/codec.ts

@@ -0,0 +1,71 @@
+import { bytesForInt } from '../../fixtures/utils/bytesFor';
+import { concatBytes } from '../../utils/buffer';
+import { unpack } from '../../utils/struct';
+import type { Serializable, SerializableStatic } from '../common/types';
+import { serializable } from '../common/types';
+import { Int } from '../primitives';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see https://github.com/ava-labs/avalanchego/blob/master/codec/linearcodec/codec.go
+ */
+@serializable()
+export class Codec {
+  _type = TypeSymbols.Codec;
+  typeToTypeID: Map<TypeSymbols, number>;
+
+  constructor(
+    private readonly typeIdToType: (SerializableStatic | undefined)[],
+  ) {
+    this.typeToTypeID = typeIdToType.reduce(
+      (agg, type, index) => (type ? agg.set(new type()._type, index) : agg),
+      new Map<TypeSymbols, number>(),
+    );
+  }
+
+  PackPrefix = (type: Serializable) => {
+    const id = this.typeToTypeID.get(type._type);
+    if (id === undefined) {
+      throw new Error(
+        `can't marshal unregistered type: ${type._type.toString()}`,
+      );
+    }
+
+    return concatBytes(bytesForInt(id), type.toBytes(this));
+  };
+
+  UnpackPrefix = <T extends Serializable>(buf: Uint8Array): [T, Uint8Array] => {
+    let typeId: Int;
+    [typeId, buf] = unpack(buf, [Int]);
+    const type = this.typeIdToType[typeId.value()];
+
+    if (type === undefined) {
+      throw new Error(
+        `couldn't unmarshal interface: unknown type ID ${typeId.value()}`,
+      );
+    }
+
+    const [entity, rest] = type.fromBytes(buf, this);
+
+    return [entity as T, rest];
+  };
+
+  static fromBytes(buf: Uint8Array, codec?: Codec) {
+    if (!codec) {
+      throw new Error('codec required');
+    }
+    return codec.UnpackPrefix(buf);
+  }
+
+  // this is placed here to satisfy serializable and should not be used directly
+  toBytes(): Uint8Array {
+    throw new Error('not implemented');
+  }
+
+  PackPrefixList(list: Serializable[]): Uint8Array {
+    return concatBytes(
+      bytesForInt(list.length),
+      ...list.map((type) => this.PackPrefix(type)),
+    );
+  }
+}

package/src/serializable/codec/index.ts

@@ -0,0 +1,2 @@
+export { Codec } from './codec';
+export { Manager } from './manager';

package/src/serializable/codec/manager.spec.ts

@@ -0,0 +1,74 @@
+import { Codec, Manager } from '.';
+import { createAssetTx, createAssetTxBytes } from '../../fixtures/avax';
+import { bytesForInt } from '../../fixtures/utils/bytesFor';
+import { concatBytes } from '../../utils/buffer';
+import { CreateAssetTx } from '../avm/createAssetTx';
+import { Bytes, Short, Stringpr } from '../primitives';
+import { jest } from '@jest/globals';
+import type { Mock } from 'jest-mock';
+
+describe('Manager', () => {
+  it('registers multiple codecs', () => {
+    const m = new Manager();
+    m.RegisterCodec(0, new Codec([]));
+    m.RegisterCodec(1, new Codec([]));
+  });
+
+  it('errors when registering a codec version twice', () => {
+    const m = new Manager();
+    m.RegisterCodec(0, new Codec([]));
+    expect(() => m.RegisterCodec(0, new Codec([]))).toThrow(
+      'duplicated codec version',
+    );
+  });
+});
+
+describe('using the codecs', () => {
+  let m: Manager;
+  let codec1: Codec;
+  beforeEach(() => {
+    m = new Manager();
+    codec1 = new Codec([Bytes]);
+
+    //filler
+    m.RegisterCodec(0, new Codec([Stringpr]));
+
+    m.RegisterCodec(1, codec1);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('chooses the right codec', () => {
+    CreateAssetTx.fromBytes = jest.fn(() => [
+      createAssetTx(),
+      new Uint8Array(),
+    ]) as Mock<() => [CreateAssetTx, Uint8Array]>;
+
+    const input = concatBytes(new Short(1).toBytes(), createAssetTxBytes());
+
+    m.unpack(input, CreateAssetTx);
+
+    expect(CreateAssetTx.fromBytes).toBeCalledWith(
+      createAssetTxBytes(),
+      codec1,
+    );
+  });
+
+  it('packs with correct prefix', () => {
+    const tx = createAssetTx();
+    codec1.PackPrefix = jest.fn(() =>
+      concatBytes(bytesForInt(2), createAssetTxBytes()),
+    );
+    const bytes = m.packCodec(tx, 1);
+
+    const output = concatBytes(
+      new Short(1).toBytes(),
+      concatBytes(bytesForInt(2), createAssetTxBytes()),
+    );
+
+    expect(codec1.PackPrefix).toBeCalledWith(tx);
+    expect(bytes).toEqual(output);
+  });
+});

package/src/serializable/codec/manager.ts

@@ -0,0 +1,66 @@
+import { DEFAULT_CODEC_VERSION } from '../../constants/codec';
+import { concatBytes } from '../../utils/buffer';
+import type { FromBytesReturn } from '../../utils/struct';
+import { unpack } from '../../utils/struct';
+import type { Transaction } from '../../vms/common/transaction';
+import type { Serializable, SerializableStatic } from '../common/types';
+import { Short } from '../primitives';
+import type { Codec } from './codec';
+
+/**
+ * @see https://github.com/ava-labs/avalanchego/blob/master/codec/manager.go
+ */
+export class Manager {
+  codecs: Record<number, Codec> = {};
+  RegisterCodec(version: number, codec: Codec) {
+    if (version in this.codecs) {
+      throw new Error('duplicated codec version');
+    }
+
+    this.codecs[version] = codec;
+  }
+
+  unpack = <T extends SerializableStatic>(
+    buff: Uint8Array,
+    unpacker: T,
+  ): FromBytesReturn<T> => {
+    const [codec, rest] = this.getCodecFromBuffer(buff);
+    // TODO: try to do this without casting
+    return unpacker.fromBytes(rest, codec)[0] as FromBytesReturn<T>;
+  };
+
+  unpackTransaction = (buff: Uint8Array): Transaction => {
+    const [codec, rest] = this.getCodecFromBuffer(buff);
+    return codec.UnpackPrefix<Transaction>(rest)[0];
+  };
+
+  public getCodecFromBuffer(buff: Uint8Array): [Codec, Uint8Array] {
+    const [codecId, rest] = unpack(buff, [Short]);
+    const codec = this.getCodecForVersion(codecId);
+    return [codec, rest];
+  }
+
+  getCodecForVersion(codecId: Short): Codec {
+    if (!this.codecs[codecId.value()]) {
+      throw new Error(`codec id(${codecId.value()}) not found`);
+    }
+    return this.codecs[codecId.value()];
+  }
+
+  getDefaultCodec() {
+    return this.getCodecForVersion(new Short(DEFAULT_CODEC_VERSION));
+  }
+
+  getDefaultCodecId() {
+    return new Short(DEFAULT_CODEC_VERSION);
+  }
+
+  packCodec(
+    serializable: Serializable,
+    codecVersion = DEFAULT_CODEC_VERSION,
+  ): Uint8Array {
+    const codecIdShort = new Short(codecVersion);
+    const codec = this.getCodecForVersion(codecIdShort);
+    return concatBytes(codecIdShort.toBytes(), codec.PackPrefix(serializable));
+  }
+}

package/src/serializable/common/types.ts

@@ -0,0 +1,28 @@
+import type { Codec } from '../../serializable/codec';
+import type { TypeSymbols } from '../constants';
+
+export interface Serializable {
+  _type: TypeSymbols;
+
+  toBytes(codec: Codec): Uint8Array;
+}
+
+export interface SerializableStatic {
+  new (...args: any[]): Serializable;
+
+  fromBytes(bytes: Uint8Array, codec: Codec): [Serializable, Uint8Array];
+}
+
+export function staticImplements<T>() {
+  return <U extends T>(constructor: U) => {
+    constructor;
+  };
+}
+
+export function serializable() {
+  return staticImplements<SerializableStatic>();
+}
+
+export interface Amounter extends Serializable {
+  amount(): bigint;
+}

package/src/serializable/constants.ts

@@ -0,0 +1,88 @@
+export const AVM = 'AVM' as const;
+export const EVM = 'EVM' as const;
+export const PVM = 'PVM' as const;
+
+export type VM = typeof AVM | typeof EVM | typeof PVM;
+export const ValidVMs = [AVM, EVM, PVM] as const;
+
+export enum TypeSymbols {
+  Codec = 'codec',
+
+  // AVAX
+  BaseTx = 'avax.BaseTx',
+  TransferableOutput = 'avax.TransferableOutput',
+  TransferableInput = 'avax.TransferableInput',
+  TransferableOp = 'avax.TransferableOp',
+  UTXOID = 'avax.UTXOID',
+  UTXO = 'avax.Utxo',
+
+  // COMMON
+  Id = 'common.Id',
+  Address = 'common.Address',
+  NodeId = 'common.NodeId',
+
+  // PRIMITIVES
+  Int = 'primitives.Int',
+  BigIntPr = 'primitives.BigInt',
+  StringPr = 'primitives.String',
+  Byte = 'primitives.Byte',
+  Bytes = 'primitives.Bytes',
+  Short = 'primitives.Short',
+
+  // SECP256k1FX
+  Input = 'secp256k1fx.Input',
+  TransferInput = 'secp256k1fx.TransferInput',
+  TransferOutput = 'secp256k1fx.TransferOutput',
+  OutputOwners = 'secp256k1fx.OutputOwners',
+  OutputOwnersList = 'secp256k1fx.OutputOwnersList',
+  Credential = 'secp256k1fx.Credential',
+  Signature = 'secp256k1fx.Signature',
+  SecpMintOperation = 'secp256k1fx.MintOperation',
+  SecpMintOutput = 'secp256k1fx.MintOutput',
+
+  // NFTFX
+  NftFxMintOperation = 'nftfx.MintOperation',
+  NftFxMintOutput = 'nftfx.MintOutput',
+  NftFxTransferOperation = 'nftfx.TransferOperation',
+  NftFxTransferOutput = 'nftfx.TransferOutput',
+  NftFxCredential = 'nftfx.Credential',
+
+  // AVM
+  AvmBaseTx = 'avm.BaseTx',
+  AvmExportTx = 'avm.ExportTx',
+  AvmImportTx = 'avm.ImportTx',
+  CreateAssetTx = 'avm.CreateAssetTx',
+  OperationTx = 'avm.OperationTx',
+  InitialState = 'avm.InitialState',
+  AvmSignedTx = 'avm.SignedTx',
+
+  // PVM
+  PvmBaseTx = 'pvm.BaseTx',
+  StakeableLockIn = 'pvm.StakeableLockIn',
+  StakeableLockOut = 'pvm.StakeableLockOut',
+  AddDelegatorTx = 'pvm.AddDelegatorTx',
+  AddValidatorTx = 'pvm.AddValidatorTx',
+  AddPermissionlessDelegatorTx = 'pvm.AddPermissionlessDelegator',
+  AddPermissionlessValidatorTx = 'pvm.AddPermissionlessValidator',
+  Validator = 'pvm.Validator',
+  SubnetValidator = 'pvm.SubnetValidator',
+  Signer = 'pvm.signer',
+  SignerEmpty = 'pvm.signerEmpty',
+  ProofOfPossession = 'pvm.proofOfPossession',
+  AddSubnetValidatorTx = 'pvm.AddSubnetValidator',
+  AdvanceTimeTx = 'pvm.AdvanceTimeTx',
+  CreateChainTx = 'pvm.CreateChainTx',
+  CreateSubnetTx = 'pvm.CreateSubnetTx',
+  PvmExportTx = 'pvm.ExportTx',
+  PvmImportTx = 'pvm.ImportTx',
+  RewardValidatorTx = 'pvm.RewardValidatorTx',
+  RemoveSubnetValidatorTx = 'pvm.RemoveSubnetValidator',
+  TransformSubnetTx = 'pvm.TransformSubnetTx',
+  TransferSubnetOwnershipTx = 'pvm.TransferSubnetOwnershipTx',
+
+  // EVM
+  EvmExportTx = 'evm.ExportTx',
+  EvmInput = 'evm.Input',
+  EvmOutput = 'evm.Output',
+  EvmImportTx = 'evm.ImportTx',
+}

package/src/serializable/evm/abstractTx.ts

@@ -0,0 +1,12 @@
+import { Transaction } from '../../vms/common/transaction';
+import { EVM } from '../constants';
+import type { Id } from '../fxs/common';
+
+export abstract class EVMTx extends Transaction {
+  abstract blockchainId: Id;
+  vm = EVM;
+
+  getBlockchainId = () => {
+    return this.blockchainId.toString();
+  };
+}

package/src/serializable/evm/codec.ts

@@ -0,0 +1,24 @@
+import { Codec, Manager } from '../codec';
+import * as Secp256k1Fx from '../fxs/secp256k1';
+import { ExportTx } from './exportTx';
+import { ImportTx } from './importTx';
+
+// https://github.com/ava-labs/coreth/blob/master/plugin/evm/codec.go
+let manager;
+export const codec = new Codec([
+  ImportTx, // 0
+  ExportTx, // 1
+
+  ...Array(3).fill(undefined),
+
+  ...Secp256k1Fx.TypeRegistry,
+  Secp256k1Fx.Input,
+  Secp256k1Fx.OutputOwners,
+]);
+
+export const getEVMManager = () => {
+  if (manager) return manager;
+  manager = new Manager();
+  manager.RegisterCodec(0, codec);
+  return manager;
+};

package/src/serializable/evm/exportTx.spec.ts

@@ -0,0 +1,6 @@
+import { testEVMCodec } from '../../fixtures/codec';
+import { exportTx, exportTxBytes } from '../../fixtures/evm';
+import { testSerialization } from '../../fixtures/utils/serializable';
+import { ExportTx } from './exportTx';
+
+testSerialization('ExportTx', ExportTx, exportTx, exportTxBytes, testEVMCodec);

package/src/serializable/evm/exportTx.ts

@@ -0,0 +1,55 @@
+import { toListStruct } from '../../utils/serializeList';
+import { packSwitched, unpack } from '../../utils/struct';
+import { serializable } from '../../vms/common/types';
+import { TransferableOutput } from '../avax/transferableOutput';
+import type { Codec } from '../codec';
+import { Id } from '../fxs/common';
+import { Int } from '../primitives';
+import { EVMTx } from './abstractTx';
+import { Input } from './input';
+import { TypeSymbols } from '../constants';
+
+/**
+ * @see
+ */
+@serializable()
+export class ExportTx extends EVMTx {
+  _type = TypeSymbols.EvmExportTx;
+
+  constructor(
+    public readonly networkId: Int,
+    public readonly blockchainId: Id,
+    public readonly destinationChain: Id,
+    public readonly ins: Input[],
+    public readonly exportedOutputs: TransferableOutput[],
+  ) {
+    super();
+  }
+  getSigIndices() {
+    return [[0]];
+  }
+
+  static fromBytes(bytes: Uint8Array, codec: Codec): [ExportTx, Uint8Array] {
+    const [networkId, blockchainId, sourceChain, ins, exportedOutputs, rest] =
+      unpack(
+        bytes,
+        [Int, Id, Id, toListStruct(Input), toListStruct(TransferableOutput)],
+        codec,
+      );
+    return [
+      new ExportTx(networkId, blockchainId, sourceChain, ins, exportedOutputs),
+      rest,
+    ];
+  }
+
+  toBytes(codec: Codec) {
+    return packSwitched(
+      codec,
+      this.networkId,
+      this.blockchainId,
+      this.destinationChain,
+      this.ins,
+      this.exportedOutputs,
+    );
+  }
+}