ghinfe 0.6.0

package/src/reforma/ibscbs.js

@@ -0,0 +1,175 @@
+/**
+ * Constantes e helpers — Reforma Tributária (NT 2025.002 / PL_010).
+ * IBS + CBS. Injeção no builder NF-e/NFC-e quando item.reforma ou reformaTributaria.
+ */
+
+export const REFORMA_LAYOUT = 'PL_010';
+
+export const CST_IBSCBS = {
+  TRIBUTACAO_INTEGRAL: '000',
+  ISENCAO: '100',
+  DIFERIMENTO: '200',
+  REDUCAO_BASE: '300',
+  SUSPENSAO: '400',
+};
+
+/**
+ * @typedef {Object} TributacaoRTC
+ * @property {string} [cst]
+ * @property {string} [cClassTrib]
+ * @property {number} [vBC]
+ * @property {number} [pIBSUF]
+ * @property {number} [pIBSMun]
+ * @property {number} [pCBS]
+ * @property {number} [vIBSUF]
+ * @property {number} [vIBSMun]
+ * @property {number} [vCBS]
+ */
+
+/**
+ * @param {number} baseCalculo
+ * @param {Omit<TributacaoRTC, 'vIBSUF'|'vIBSMun'|'vCBS'|'vBC'>} [aliquotas]
+ * @returns {TributacaoRTC & { vBC: number }}
+ */
+export function calcularIBSCBS(baseCalculo, aliquotas = {}) {
+  const pIBSUF = aliquotas.pIBSUF ?? 0;
+  const pIBSMun = aliquotas.pIBSMun ?? 0;
+  const pCBS = aliquotas.pCBS ?? 0;
+  const base = Number(baseCalculo) || 0;
+
+  return {
+    cst: aliquotas.cst ?? CST_IBSCBS.TRIBUTACAO_INTEGRAL,
+    cClassTrib: aliquotas.cClassTrib,
+    vBC: base,
+    pIBSUF,
+    pIBSMun,
+    pCBS,
+    vIBSUF: Number(((base * pIBSUF) / 100).toFixed(2)),
+    vIBSMun: Number(((base * pIBSMun) / 100).toFixed(2)),
+    vCBS: Number(((base * pCBS) / 100).toFixed(2)),
+  };
+}
+
+/**
+ * @param {TributacaoRTC} trib
+ * @returns {string}
+ */
+export function buildFragmentoIBSCBS(trib) {
+  const dec = (v, d = 2) => Number(v ?? 0).toFixed(d);
+  return `<IBSCBS>
+  <CST>${trib.cst ?? CST_IBSCBS.TRIBUTACAO_INTEGRAL}</CST>
+  ${trib.cClassTrib ? `<cClassTrib>${trib.cClassTrib}</cClassTrib>` : ''}
+  <gIBSCBS>
+    <vBC>${dec(trib.vBC ?? 0)}</vBC>
+    <gIBSUF>
+      <pIBSUF>${dec(trib.pIBSUF, 4)}</pIBSUF>
+      <vIBSUF>${dec(trib.vIBSUF)}</vIBSUF>
+    </gIBSUF>
+    <gIBSMun>
+      <pIBSMun>${dec(trib.pIBSMun, 4)}</pIBSMun>
+      <vIBSMun>${dec(trib.vIBSMun)}</vIBSMun>
+    </gIBSMun>
+    <gCBS>
+      <pCBS>${dec(trib.pCBS, 4)}</pCBS>
+      <vCBS>${dec(trib.vCBS)}</vCBS>
+    </gCBS>
+  </gIBSCBS>
+</IBSCBS>`;
+}
+
+/**
+ * Anexa grupo IBSCBS ao nó imposto (xmlbuilder2).
+ * @param {import('xmlbuilder2').XMLBuilder} impostoNode
+ * @param {TributacaoRTC} trib
+ */
+export function appendIBSCBS(impostoNode, trib) {
+  if (!trib) return;
+  const dec = (v, d = 2) => Number(v ?? 0).toFixed(d);
+  const ibs = impostoNode.ele('IBSCBS');
+  ibs.ele('CST').txt(trib.cst ?? CST_IBSCBS.TRIBUTACAO_INTEGRAL).up();
+  if (trib.cClassTrib) ibs.ele('cClassTrib').txt(trib.cClassTrib).up();
+
+  const g = ibs.ele('gIBSCBS');
+  g.ele('vBC').txt(dec(trib.vBC ?? 0)).up();
+
+  const gUf = g.ele('gIBSUF');
+  gUf.ele('pIBSUF').txt(dec(trib.pIBSUF, 4)).up();
+  gUf.ele('vIBSUF').txt(dec(trib.vIBSUF)).up();
+  gUf.up();
+
+  const gMun = g.ele('gIBSMun');
+  gMun.ele('pIBSMun').txt(dec(trib.pIBSMun, 4)).up();
+  gMun.ele('vIBSMun').txt(dec(trib.vIBSMun)).up();
+  gMun.up();
+
+  const gCbs = g.ele('gCBS');
+  gCbs.ele('pCBS').txt(dec(trib.pCBS, 4)).up();
+  gCbs.ele('vCBS').txt(dec(trib.vCBS)).up();
+  gCbs.up();
+
+  g.up();
+  ibs.up();
+}
+
+/**
+ * Anexa totais IBS/CBS em &lt;total&gt; (irmão de ICMSTot).
+ * @param {import('xmlbuilder2').XMLBuilder} totalParent
+ * @param {{ vIBSUF: number, vIBSMun: number, vCBS: number }} totais
+ */
+export function appendTotaisIBSCBS(totalParent, totais) {
+  if (!totais) return;
+  const dec = (v) => Number(v ?? 0).toFixed(2);
+  const node = totalParent.ele('IBSCBSTot');
+  node.ele('vIBS').txt(dec((totais.vIBSUF ?? 0) + (totais.vIBSMun ?? 0))).up();
+  node.ele('vIBSUF').txt(dec(totais.vIBSUF)).up();
+  node.ele('vIBSMun').txt(dec(totais.vIBSMun)).up();
+  node.ele('vCBS').txt(dec(totais.vCBS)).up();
+  node.up();
+}
+
+/**
+ * @param {Array<{ reforma?: TributacaoRTC, valorTotal?: number }>} itens
+ * @param {boolean} [autoCalcular]
+ */
+export function normalizarItensReforma(itens = [], autoCalcular = false) {
+  return itens.map((item) => {
+    if (item.reforma) {
+      if (item.reforma.vIBSUF == null && autoCalcular !== false) {
+        return {
+          ...item,
+          reforma: calcularIBSCBS(item.reforma.vBC ?? item.valorTotal ?? 0, item.reforma),
+        };
+      }
+      return item;
+    }
+    return item;
+  });
+}
+
+/**
+ * @param {Array<{ reforma?: TributacaoRTC }>} itens
+ */
+export function somarTotaisReforma(itens = []) {
+  return itens.reduce(
+    (acc, item) => {
+      const r = item.reforma;
+      if (!r) return acc;
+      acc.vIBSUF += r.vIBSUF ?? 0;
+      acc.vIBSMun += r.vIBSMun ?? 0;
+      acc.vCBS += r.vCBS ?? 0;
+      return acc;
+    },
+    { vIBSUF: 0, vIBSMun: 0, vCBS: 0 }
+  );
+}
+
+/**
+ * @param {{ reformaTributaria?: boolean, itens?: Array<{ reforma?: unknown }> }} documentoOuOptions
+ */
+export function reformaHabilitada(documentoOuOptions = {}) {
+  if (documentoOuOptions.reformaTributaria) return true;
+  if (Array.isArray(documentoOuOptions.itens)) {
+    return documentoOuOptions.itens.some((i) => i.reforma);
+  }
+  return false;
+}

package/src/sefaz/SefazEndpointResolver.js

@@ -0,0 +1,95 @@
+import { UF_AUTORIZADOR, AUTORIZADOR_ENDPOINTS, SEFAZ_SERVICO } from './endpoints.registry.js';
+import { GhinfeError } from '../errors/GhinfeError.js';
+
+/**
+ * Resolve endpoints SEFAZ por UF, ambiente e tipo de serviço.
+ * Elimina necessidade de configurar URLs manualmente em produção.
+ */
+export class SefazEndpointResolver {
+  /**
+   * @param {string} uf Sigla da UF (ex: "SP")
+   * @returns {string} Código do autorizador (ex: "SVRS", "SP")
+   */
+  static obterAutorizador(uf) {
+    const autorizador = UF_AUTORIZADOR[uf?.toUpperCase()];
+    if (!autorizador) {
+      throw new GhinfeError(`UF não mapeada para autorizador SEFAZ: ${uf}`, 'UF_AUTORIZADOR_NOT_FOUND');
+    }
+    return autorizador;
+  }
+
+  /**
+   * @param {string} uf
+   * @param {number} [ambiente] 1=Produção, 2=Homologação
+   * @returns {Record<string, string>}
+   */
+  static obterEndpoints(uf, ambiente = 2) {
+    const autorizador = this.obterAutorizador(uf);
+    const endpoints = AUTORIZADOR_ENDPOINTS[autorizador]?.[ambiente];
+
+    if (!endpoints) {
+      throw new GhinfeError(
+        `Endpoints não configurados para autorizador ${autorizador} ambiente ${ambiente}`,
+        'SEFAZ_ENDPOINTS_NOT_FOUND'
+      );
+    }
+
+    return { autorizador, ambiente, endpoints };
+  }
+
+  /**
+   * @param {{
+   *   uf: string,
+   *   ambiente?: number,
+   *   servico?: string,
+   *   modelo?: '55'|'65',
+   * }} params
+   * @returns {string}
+   */
+  static resolver(params) {
+    const { endpoints } = this.obterEndpoints(params.uf, params.ambiente ?? 2);
+    const servico = params.servico ?? SEFAZ_SERVICO.AUTORIZACAO;
+    const url = endpoints[servico];
+
+    if (!url) {
+      throw new GhinfeError(
+        `Serviço "${servico}" não disponível para UF ${params.uf} (autorizador ${this.obterAutorizador(params.uf)})`,
+        'SEFAZ_SERVICO_NOT_FOUND',
+        { servico, uf: params.uf, modelo: params.modelo }
+      );
+    }
+
+    return url;
+  }
+
+  /**
+   * Configuração pronta para NFeSoapService.
+   * @param {string} uf
+   * @param {number} [ambiente]
+   */
+  static paraNFe(uf, ambiente = 2) {
+    return {
+      endpoint: this.resolver({ uf, ambiente, servico: SEFAZ_SERVICO.AUTORIZACAO, modelo: '55' }),
+      eventoEndpoint: this.resolver({ uf, ambiente, servico: SEFAZ_SERVICO.EVENTO, modelo: '55' }),
+    };
+  }
+
+  /**
+   * NFC-e usa os mesmos webservices de autorização na maioria dos estados.
+   * @param {string} uf
+   * @param {number} [ambiente]
+   */
+  static paraNFCe(uf, ambiente = 2) {
+    return {
+      endpoint: this.resolver({ uf, ambiente, servico: SEFAZ_SERVICO.AUTORIZACAO, modelo: '65' }),
+      eventoEndpoint: this.resolver({ uf, ambiente, servico: SEFAZ_SERVICO.EVENTO, modelo: '65' }),
+    };
+  }
+
+  /** @returns {string[]} */
+  static listarUFs() {
+    return Object.keys(UF_AUTORIZADOR);
+  }
+}
+
+export { SEFAZ_SERVICO };

package/src/sefaz/endpoints.registry.js

@@ -0,0 +1,205 @@
+/**
+ * Mapeamento UF → autorizador SEFAZ (NF-e/NFC-e).
+ * Fonte: Manual de Orientação do Contribuinte / tabela de autorizadores.
+ */
+export const UF_AUTORIZADOR = {
+  AC: 'SVRS', AL: 'SVRS', AM: 'AM', AP: 'SVRS', BA: 'BA',
+  CE: 'SVRS', DF: 'SVRS', ES: 'SVRS', GO: 'GO', MA: 'SVAN',
+  MG: 'MG', MS: 'MS', MT: 'MT', PA: 'SVAN', PB: 'SVRS',
+  PE: 'PE', PI: 'SVRS', PR: 'PR', RJ: 'SVRS', RN: 'SVRS',
+  RO: 'SVRS', RR: 'SVRS', RS: 'RS', SC: 'SVRS', SE: 'SVRS',
+  SP: 'SP', TO: 'SVRS',
+};
+
+/** Tipos de webservice SEFAZ. */
+export const SEFAZ_SERVICO = {
+  AUTORIZACAO: 'autorizacao',
+  RET_AUTORIZACAO: 'retAutorizacao',
+  CONSULTA: 'consulta',
+  EVENTO: 'evento',
+  INUTILIZACAO: 'inutilizacao',
+  STATUS: 'status',
+};
+
+/**
+ * Endpoints por autorizador e ambiente.
+ * ambiente: 1=Produção, 2=Homologação
+ */
+export const AUTORIZADOR_ENDPOINTS = {
+  SVRS: {
+    1: {
+      autorizacao: 'https://nfe.svrs.rs.gov.br/ws/NfeAutorizacao/NFeAutorizacao4.asmx',
+      retAutorizacao: 'https://nfe.svrs.rs.gov.br/ws/NfeRetAutorizacao/NFeRetAutorizacao4.asmx',
+      consulta: 'https://nfe.svrs.rs.gov.br/ws/NfeConsulta/NfeConsulta4.asmx',
+      evento: 'https://nfe.svrs.rs.gov.br/ws/recepcaoevento/ReceptionEvent4.asmx',
+      inutilizacao: 'https://nfe.svrs.rs.gov.br/ws/nfeinutilizacao/nfeinutilizacao4.asmx',
+      status: 'https://nfe.svrs.rs.gov.br/ws/NfeStatusServico/NfeStatusServico4.asmx',
+    },
+    2: {
+      autorizacao: 'https://nfe-homologacao.svrs.rs.gov.br/ws/NfeAutorizacao/NFeAutorizacao4.asmx',
+      retAutorizacao: 'https://nfe-homologacao.svrs.rs.gov.br/ws/NfeRetAutorizacao/NFeRetAutorizacao4.asmx',
+      consulta: 'https://nfe-homologacao.svrs.rs.gov.br/ws/NfeConsulta/NfeConsulta4.asmx',
+      evento: 'https://nfe-homologacao.svrs.rs.gov.br/ws/recepcaoevento/ReceptionEvent4.asmx',
+      inutilizacao: 'https://nfe-homologacao.svrs.rs.gov.br/ws/nfeinutilizacao/nfeinutilizacao4.asmx',
+      status: 'https://nfe-homologacao.svrs.rs.gov.br/ws/NfeStatusServico/NfeStatusServico4.asmx',
+    },
+  },
+  SVAN: {
+    1: {
+      autorizacao: 'https://www.sefazvirtual.fazenda.gov.br/NFeAutorizacao4/NFeAutorizacao4.asmx',
+      retAutorizacao: 'https://www.sefazvirtual.fazenda.gov.br/NFeRetAutorizacao4/NFeRetAutorizacao4.asmx',
+      consulta: 'https://www.sefazvirtual.fazenda.gov.br/NFeConsultaProtocolo4/NFeConsultaProtocolo4.asmx',
+      evento: 'https://www.sefazvirtual.fazenda.gov.br/NFeRecepcaoEvento4/NFeRecepcaoEvento4.asmx',
+      inutilizacao: 'https://www.sefazvirtual.fazenda.gov.br/NFeInutilizacao4/NFeInutilizacao4.asmx',
+      status: 'https://www.sefazvirtual.fazenda.gov.br/NFeStatusServico4/NFeStatusServico4.asmx',
+    },
+    2: {
+      autorizacao: 'https://hom.sefazvirtual.fazenda.gov.br/NFeAutorizacao4/NFeAutorizacao4.asmx',
+      retAutorizacao: 'https://hom.sefazvirtual.fazenda.gov.br/NFeRetAutorizacao4/NFeRetAutorizacao4.asmx',
+      consulta: 'https://hom.sefazvirtual.fazenda.gov.br/NFeConsultaProtocolo4/NFeConsultaProtocolo4.asmx',
+      evento: 'https://hom.sefazvirtual.fazenda.gov.br/NFeRecepcaoEvento4/NFeRecepcaoEvento4.asmx',
+      inutilizacao: 'https://hom.sefazvirtual.fazenda.gov.br/NFeInutilizacao4/NFeInutilizacao4.asmx',
+      status: 'https://hom.sefazvirtual.fazenda.gov.br/NFeStatusServico4/NFeStatusServico4.asmx',
+    },
+  },
+  SP: {
+    1: {
+      autorizacao: 'https://nfe.fazenda.sp.gov.br/ws/nfeautorizacao4.asmx',
+      retAutorizacao: 'https://nfe.fazenda.sp.gov.br/ws/nferetautorizacao4.asmx',
+      consulta: 'https://nfe.fazenda.sp.gov.br/ws/nfeconsultaprotocolo4.asmx',
+      evento: 'https://nfe.fazenda.sp.gov.br/ws/nferecepcaoevento4.asmx',
+      inutilizacao: 'https://nfe.fazenda.sp.gov.br/ws/nfeinutilizacao4.asmx',
+      status: 'https://nfe.fazenda.sp.gov.br/ws/nfestatusservico4.asmx',
+    },
+    2: {
+      autorizacao: 'https://homologacao.nfe.fazenda.sp.gov.br/ws/nfeautorizacao4.asmx',
+      retAutorizacao: 'https://homologacao.nfe.fazenda.sp.gov.br/ws/nferetautorizacao4.asmx',
+      consulta: 'https://homologacao.nfe.fazenda.sp.gov.br/ws/nfeconsultaprotocolo4.asmx',
+      evento: 'https://homologacao.nfe.fazenda.sp.gov.br/ws/nferecepcaoevento4.asmx',
+      inutilizacao: 'https://homologacao.nfe.fazenda.sp.gov.br/ws/nfeinutilizacao4.asmx',
+      status: 'https://homologacao.nfe.fazenda.sp.gov.br/ws/nfestatusservico4.asmx',
+    },
+  },
+  MG: {
+    1: {
+      autorizacao: 'https://nfe.fazenda.mg.gov.br/nfe2/services/NFeAutorizacao4',
+      retAutorizacao: 'https://nfe.fazenda.mg.gov.br/nfe2/services/NFeRetAutorizacao4',
+      consulta: 'https://nfe.fazenda.mg.gov.br/nfe2/services/NFeConsultaProtocolo4',
+      evento: 'https://nfe.fazenda.mg.gov.br/nfe2/services/NFeRecepcaoEvento4',
+      inutilizacao: 'https://nfe.fazenda.mg.gov.br/nfe2/services/NFeInutilizacao4',
+      status: 'https://nfe.fazenda.mg.gov.br/nfe2/services/NFeStatusServico4',
+    },
+    2: {
+      autorizacao: 'https://hnfe.fazenda.mg.gov.br/nfe2/services/NFeAutorizacao4',
+      retAutorizacao: 'https://hnfe.fazenda.mg.gov.br/nfe2/services/NFeRetAutorizacao4',
+      consulta: 'https://hnfe.fazenda.mg.gov.br/nfe2/services/NFeConsultaProtocolo4',
+      evento: 'https://hnfe.fazenda.mg.gov.br/nfe2/services/NFeRecepcaoEvento4',
+      inutilizacao: 'https://hnfe.fazenda.mg.gov.br/nfe2/services/NFeInutilizacao4',
+      status: 'https://hnfe.fazenda.mg.gov.br/nfe2/services/NFeStatusServico4',
+    },
+  },
+  PR: {
+    1: {
+      autorizacao: 'https://nfe.sefa.pr.gov.br/nfe/NFeAutorizacao4',
+      retAutorizacao: 'https://nfe.sefa.pr.gov.br/nfe/NFeRetAutorizacao4',
+      consulta: 'https://nfe.sefa.pr.gov.br/nfe/NFeConsultaProtocolo4',
+      evento: 'https://nfe.sefa.pr.gov.br/nfe/NFeRecepcaoEvento4',
+      inutilizacao: 'https://nfe.sefa.pr.gov.br/nfe/NFeInutilizacao4',
+      status: 'https://nfe.sefa.pr.gov.br/nfe/NFeStatusServico4',
+    },
+    2: {
+      autorizacao: 'https://homologacao.nfe.sefa.pr.gov.br/nfe/NFeAutorizacao4',
+      retAutorizacao: 'https://homologacao.nfe.sefa.pr.gov.br/nfe/NFeRetAutorizacao4',
+      consulta: 'https://homologacao.nfe.sefa.pr.gov.br/nfe/NFeConsultaProtocolo4',
+      evento: 'https://homologacao.nfe.sefa.pr.gov.br/nfe/NFeRecepcaoEvento4',
+      inutilizacao: 'https://homologacao.nfe.sefa.pr.gov.br/nfe/NFeInutilizacao4',
+      status: 'https://homologacao.nfe.sefa.pr.gov.br/nfe/NFeStatusServico4',
+    },
+  },
+  RS: {
+    1: {
+      autorizacao: 'https://nfe.sefazrs.rs.gov.br/ws/NfeAutorizacao/NFeAutorizacao4.asmx',
+      retAutorizacao: 'https://nfe.sefazrs.rs.gov.br/ws/NfeRetAutorizacao/NFeRetAutorizacao4.asmx',
+      consulta: 'https://nfe.sefazrs.rs.gov.br/ws/NfeConsulta/NfeConsulta4.asmx',
+      evento: 'https://nfe.sefazrs.rs.gov.br/ws/recepcaoevento/ReceptionEvent4.asmx',
+      inutilizacao: 'https://nfe.sefazrs.rs.gov.br/ws/nfeinutilizacao/nfeinutilizacao4.asmx',
+      status: 'https://nfe.sefazrs.rs.gov.br/ws/NfeStatusServico/NfeStatusServico4.asmx',
+    },
+    2: {
+      autorizacao: 'https://nfe-homologacao.sefazrs.rs.gov.br/ws/NfeAutorizacao/NFeAutorizacao4.asmx',
+      retAutorizacao: 'https://nfe-homologacao.sefazrs.rs.gov.br/ws/NfeRetAutorizacao/NFeRetAutorizacao4.asmx',
+      consulta: 'https://nfe-homologacao.sefazrs.rs.gov.br/ws/NfeConsulta/NfeConsulta4.asmx',
+      evento: 'https://nfe-homologacao.sefazrs.rs.gov.br/ws/recepcaoevento/ReceptionEvent4.asmx',
+      inutilizacao: 'https://nfe-homologacao.sefazrs.rs.gov.br/ws/nfeinutilizacao/nfeinutilizacao4.asmx',
+      status: 'https://nfe-homologacao.sefazrs.rs.gov.br/ws/NfeStatusServico/NfeStatusServico4.asmx',
+    },
+  },
+  MS: {
+    1: {
+      autorizacao: 'https://nfe.sefaz.ms.gov.br/ws/NfeAutorizacao4',
+      evento: 'https://nfe.sefaz.ms.gov.br/ws/NfeRecepcaoEvento4',
+      consulta: 'https://nfe.sefaz.ms.gov.br/ws/NfeConsulta4',
+      status: 'https://nfe.sefaz.ms.gov.br/ws/NfeStatusServico4',
+    },
+    2: {
+      autorizacao: 'https://homologacao.nfe.ms.gov.br/ws/NfeAutorizacao4',
+      evento: 'https://homologacao.nfe.ms.gov.br/ws/NfeRecepcaoEvento4',
+      consulta: 'https://homologacao.nfe.ms.gov.br/ws/NfeConsulta4',
+      status: 'https://homologacao.nfe.ms.gov.br/ws/NfeStatusServico4',
+    },
+  },
+  MT: {
+    1: {
+      autorizacao: 'https://nfe.sefaz.mt.gov.br/nfews/v2/services/NfeAutorizacao4',
+      evento: 'https://nfe.sefaz.mt.gov.br/nfews/v2/services/RecepcaoEvento4',
+      consulta: 'https://nfe.sefaz.mt.gov.br/nfews/v2/services/NfeConsulta4',
+    },
+    2: {
+      autorizacao: 'https://homologacao.sefaz.mt.gov.br/nfews/v2/services/NfeAutorizacao4',
+      evento: 'https://homologacao.sefaz.mt.gov.br/nfews/v2/services/RecepcaoEvento4',
+      consulta: 'https://homologacao.sefaz.mt.gov.br/nfews/v2/services/NfeConsulta4',
+    },
+  },
+  GO: {
+    1: {
+      autorizacao: 'https://nfe.sefaz.go.gov.br/nfe/services/NFeAutorizacao4',
+      evento: 'https://nfe.sefaz.go.gov.br/nfe/services/NFeRecepcaoEvento4',
+      consulta: 'https://nfe.sefaz.go.gov.br/nfe/services/NFeConsultaProtocolo4',
+    },
+    2: {
+      autorizacao: 'https://homolog.sefaz.go.gov.br/nfe/services/NFeAutorizacao4',
+      evento: 'https://homolog.sefaz.go.gov.br/nfe/services/NFeRecepcaoEvento4',
+      consulta: 'https://homolog.sefaz.go.gov.br/nfe/services/NFeConsultaProtocolo4',
+    },
+  },
+  AM: {
+    1: {
+      autorizacao: 'https://nfe.sefaz.am.gov.br/services2/services/NfeAutorizacao4',
+      evento: 'https://nfe.sefaz.am.gov.br/services2/services/RecepcaoEvento4',
+    },
+    2: {
+      autorizacao: 'https://homnfe.sefaz.am.gov.br/services2/services/NfeAutorizacao4',
+      evento: 'https://homnfe.sefaz.am.gov.br/services2/services/RecepcaoEvento4',
+    },
+  },
+  BA: {
+    1: {
+      autorizacao: 'https://nfe.sefaz.ba.gov.br/webservices/NFeAutorizacao4/NFeAutorizacao4.asmx',
+      evento: 'https://nfe.sefaz.ba.gov.br/webservices/NFeRecepcaoEvento4/NFeRecepcaoEvento4.asmx',
+    },
+    2: {
+      autorizacao: 'https://hnfe.sefaz.ba.gov.br/webservices/NFeAutorizacao4/NFeAutorizacao4.asmx',
+      evento: 'https://hnfe.sefaz.ba.gov.br/webservices/NFeRecepcaoEvento4/NFeRecepcaoEvento4.asmx',
+    },
+  },
+  PE: {
+    1: {
+      autorizacao: 'https://nfe.sefaz.pe.gov.br/nfe-service/services/NFeAutorizacao4',
+      evento: 'https://nfe.sefaz.pe.gov.br/nfe-service/services/NFeRecepcaoEvento4',
+    },
+    2: {
+      autorizacao: 'https://nfehomolog.sefaz.pe.gov.br/nfe-service/services/NFeAutorizacao4',
+      evento: 'https://nfehomolog.sefaz.pe.gov.br/nfe-service/services/NFeRecepcaoEvento4',
+    },
+  },
+};

package/src/shared/fiscal.helpers.js

@@ -0,0 +1,53 @@
+import { UF_IBGE } from '../constants/sefaz.js';
+import { appendIBSCBS } from '../reforma/ibscbs.js';
+
+/** @param {string} uf */
+export function codigoUf(uf) {
+  return UF_IBGE[uf?.toUpperCase()] ?? '35';
+}
+
+/** @param {number} value @param {number} decimals */
+export function formatDecimal(value, decimals) {
+  return Number(value).toFixed(decimals);
+}
+
+/**
+ * @param {import('xmlbuilder2').XMLBuilder} parent
+ * @param {string} tag
+ * @param {import('../nfe/types/NFeDocument.js').NFeEndereco} endereco
+ */
+export function appendEndereco(parent, tag, endereco) {
+  const node = parent.ele(tag);
+  node.ele('xLgr').txt(endereco.logradouro).up();
+  node.ele('nro').txt(endereco.numero).up();
+  if (endereco.complemento) node.ele('xCpl').txt(endereco.complemento).up();
+  node.ele('xBairro').txt(endereco.bairro).up();
+  node.ele('cMun').txt(endereco.codigoMunicipio).up();
+  node.ele('xMun').txt(endereco.municipio).up();
+  node.ele('UF').txt(endereco.uf).up();
+  node.ele('CEP').txt(endereco.cep.replace(/\D/g, '')).up();
+  if (endereco.telefone) node.ele('fone').txt(endereco.telefone.replace(/\D/g, '')).up();
+  node.up();
+}
+
+/**
+ * @param {import('xmlbuilder2').XMLBuilder} impostoNode
+ * @param {import('../nfe/types/NFeDocument.js').NFeItem} item
+ */
+export function appendImpostosItem(impostoNode, item) {
+  const icms = impostoNode.ele('ICMS').ele('ICMS00');
+  icms.ele('orig').txt('0').up();
+  icms.ele('CST').txt(item.cst ?? '00').up();
+  icms.ele('modBC').txt('0').up();
+  icms.ele('vBC').txt(formatDecimal(item.valorTotal, 2)).up();
+  icms.ele('pICMS').txt(formatDecimal(item.aliquotaIcms ?? 0, 4)).up();
+  icms.ele('vICMS').txt(formatDecimal(item.valorIcms ?? 0, 2)).up();
+  icms.up().up();
+
+  impostoNode.ele('PIS').ele('PISNT').ele('CST').txt('07').up().up().up();
+  impostoNode.ele('COFINS').ele('COFINSNT').ele('CST').txt('07').up().up().up();
+
+  if (item.reforma) {
+    appendIBSCBS(impostoNode, item.reforma);
+  }
+}

package/src/utils/certificate.utils.js

@@ -0,0 +1,47 @@
+import forge from 'node-forge';
+import { GhinfeError } from '../errors/GhinfeError.js';
+
+/**
+ * Carrega certificado A1 (.pfx / .p12) e retorna chave privada + certificado PEM.
+ * @param {Buffer|string} pfxBuffer
+ * @param {string} password
+ * @returns {{ privateKeyPem: string, certificatePem: string, certificate: forge.pki.Certificate }}
+ */
+export function loadPfxCertificate(pfxBuffer, password) {
+  try {
+    const buffer = Buffer.isBuffer(pfxBuffer) ? pfxBuffer : Buffer.from(pfxBuffer);
+    const p12Asn1 = forge.asn1.fromDer(buffer.toString('binary'));
+    const p12 = forge.pkcs12.pkcs12FromAsn1(p12Asn1, password);
+
+    const certBags = p12.getBags({ bagType: forge.pki.oids.certBag });
+    const keyBags = p12.getBags({ bagType: forge.pki.oids.pkcs8ShroudedKeyBag });
+
+    const certBag = certBags[forge.pki.oids.certBag]?.[0];
+    const keyBag =
+      keyBags[forge.pki.oids.pkcs8ShroudedKeyBag]?.[0] ??
+      p12.getBags({ bagType: forge.pki.oids.keyBag })[forge.pki.oids.keyBag]?.[0];
+
+    if (!certBag?.cert || !keyBag?.key) {
+      throw new GhinfeError(
+        'Certificado ou chave privada não encontrados no arquivo PFX',
+        'CERT_NOT_FOUND'
+      );
+    }
+
+    const certificate = certBag.cert;
+    const privateKey = keyBag.key;
+
+    return {
+      privateKeyPem: forge.pki.privateKeyToPem(privateKey),
+      certificatePem: forge.pki.certificateToPem(certificate),
+      certificate,
+    };
+  } catch (error) {
+    if (error instanceof GhinfeError) throw error;
+    throw new GhinfeError(
+      'Falha ao carregar certificado PFX. Verifique o arquivo e a senha.',
+      'CERT_LOAD_ERROR',
+      error
+    );
+  }
+}