@nokinc-flur/sdk 1.0.6 → 1.1.1

package/dist/index.cjs

@@ -23,9 +23,12 @@ __export(index_exports, {
   ACCOUNT_STATUSES: () => ACCOUNT_STATUSES,
   ACCOUNT_TYPES: () => ACCOUNT_TYPES,
   ADDITIONAL_DATA_SUBFIELD: () => ADDITIONAL_DATA_SUBFIELD,
+  ARTIFACT_BODY_SCHEMAS: () => ARTIFACT_BODY_SCHEMAS,
+  ARTIFACT_TYPES: () => ARTIFACT_TYPES,
   AccountMembershipSchema: () => AccountMembershipSchema,
   AccountSchema: () => AccountSchema,
   ApiCredentialPublicSchema: () => ApiCredentialPublicSchema,
+  ArtifactHeaderSchema: () => ArtifactHeaderSchema,
   COLLECTION_INTENT_STATUSES: () => COLLECTION_INTENT_STATUSES,
   COLLECTION_PAYMENT_STATUSES: () => COLLECTION_PAYMENT_STATUSES,
   CUSTODIAL_MODES: () => CUSTODIAL_MODES,
@@ -50,14 +53,21 @@ __export(index_exports, {
   EnableOfflineInputSchema: () => EnableOfflineInputSchema,
   EnableOfflineResultSchema: () => EnableOfflineResultSchema,
   FIELD: () => FIELD,
+  FLUR_ARTIFACT_URI_PREFIX: () => FLUR_ARTIFACT_URI_PREFIX,
+  FLUR_ARTIFACT_URI_SCHEME: () => FLUR_ARTIFACT_URI_SCHEME,
+  FLUR_ARTIFACT_VERSION: () => FLUR_ARTIFACT_VERSION,
   FlurApiError: () => FlurApiError,
+  FlurArtifactError: () => FlurArtifactError,
   FlurCapExceededError: () => FlurCapExceededError,
   FlurClient: () => FlurClient,
   FlurError: () => FlurError,
   FlurExpiredError: () => FlurExpiredError,
   FlurReplayError: () => FlurReplayError,
+  HARDENED_ARTIFACT_TYPES: () => HARDENED_ARTIFACT_TYPES,
+  IdentityArtifactSchema: () => IdentityArtifactSchema,
   IngestFundingResultSchema: () => IngestFundingResultSchema,
   IssueOACInputSchema: () => IssueOACInputSchema,
+  LedgerJournalEntryArtifactSchema: () => LedgerJournalEntryArtifactSchema,
   ListPayoutDestinationsResultSchema: () => ListPayoutDestinationsResultSchema,
   MEMBERSHIP_ROLES: () => MEMBERSHIP_ROLES,
   MERCHANT_PAYOUT_STATUSES: () => MERCHANT_PAYOUT_STATUSES,
@@ -68,11 +78,14 @@ __export(index_exports, {
   NGN_CURRENCY_CODE: () => NGN_CURRENCY_CODE,
   NG_COUNTRY_CODE: () => NG_COUNTRY_CODE,
   NQRParseError: () => NQRParseError,
+  NqrPaymentRequestArtifactSchema: () => NqrPaymentRequestArtifactSchema,
   OACSchema: () => OACSchema,
   OAC_DEFAULT_CUMULATIVE_KOBO: () => OAC_DEFAULT_CUMULATIVE_KOBO,
   OAC_DEFAULT_PER_TX_KOBO: () => OAC_DEFAULT_PER_TX_KOBO,
   OAC_DEFAULT_VALIDITY_MS: () => OAC_DEFAULT_VALIDITY_MS,
+  OfflineClaimArtifactSchema: () => OfflineClaimArtifactSchema,
   OfflineHoldRecordSchema: () => OfflineHoldRecordSchema,
+  OfflinePaymentAuthorizationArtifactSchema: () => OfflinePaymentAuthorizationArtifactSchema,
   OfflinePaymentAuthorizationSchema: () => OfflinePaymentAuthorizationSchema,
   OfflinePaymentRequestSchema: () => OfflinePaymentRequestSchema,
   OfflineStateResultSchema: () => OfflineStateResultSchema,
@@ -91,10 +104,12 @@ __export(index_exports, {
   PartnerFundingEventInputSchema: () => PartnerFundingEventInputSchema,
   PartnerFundingSchema: () => PartnerFundingSchema,
   PartnerProfileSchema: () => PartnerProfileSchema,
+  PassArtifactSchema: () => PassArtifactSchema,
   PassMetadataSchema: () => PassMetadataSchema,
   PassSchema: () => PassSchema,
   PayCollectionInputSchema: () => PayCollectionInputSchema,
   PaymentClaimSchema: () => PaymentClaimSchema,
+  PaymentIntentArtifactSchema: () => PaymentIntentArtifactSchema,
   PayoutDestinationSchema: () => PayoutDestinationSchema,
   PayoutEventInputSchema: () => PayoutEventInputSchema,
   ProviderEventInputSchema: () => ProviderEventInputSchema,
@@ -103,22 +118,29 @@ __export(index_exports, {
   RECEIPT_CHANNELS: () => RECEIPT_CHANNELS,
   RECEIPT_KINDS: () => RECEIPT_KINDS,
   REPLAY_WINDOW_MS: () => REPLAY_WINDOW_MS,
+  ReceiptArtifactSchema: () => ReceiptArtifactSchema,
   ReceiptPayloadSchema: () => ReceiptPayloadSchema,
   ReceiptSchema: () => ReceiptSchema,
   ReconciliationReportSchema: () => ReconciliationReportSchema,
   RecordPayoutEventResultSchema: () => RecordPayoutEventResultSchema,
   RedemptionSchema: () => RedemptionSchema,
   RegisterDeviceKeyInputSchema: () => RegisterDeviceKeyInputSchema,
+  ReversalRecordArtifactSchema: () => ReversalRecordArtifactSchema,
   RevokeDeviceKeyInputSchema: () => RevokeDeviceKeyInputSchema,
   SETTLEMENT_SCHEDULES: () => SETTLEMENT_SCHEDULES,
   SettleResponseSchema: () => SettleResponseSchema,
+  SettlementRecordArtifactSchema: () => SettlementRecordArtifactSchema,
   SettlementSchema: () => SettlementSchema,
   SignedConsumerOACSchema: () => SignedConsumerOACSchema,
+  StatementArtifactSchema: () => StatementArtifactSchema,
   UpsertMerchantProfileInputSchema: () => UpsertMerchantProfileInputSchema,
   UpsertPartnerProfileInputSchema: () => UpsertPartnerProfileInputSchema,
   WITHDRAWAL_STATES: () => WITHDRAWAL_STATES,
   WithdrawalSchema: () => WithdrawalSchema,
+  base64UrlDecode: () => base64UrlDecode,
+  base64UrlEncode: () => base64UrlEncode,
   bodySha256Hex: () => bodySha256Hex,
+  buildArtifactBody: () => buildArtifactBody,
   buildAuthorization: () => buildAuthorization,
   buildOAC: () => buildOAC,
   buildPass: () => buildPass,
@@ -134,21 +156,26 @@ __export(index_exports, {
   crc16ccittHex: () => crc16ccittHex,
   createAccountsClient: () => createAccountsClient,
   createApiCredentialsAdminClient: () => createApiCredentialsAdminClient,
+  createArtifactUri: () => createArtifactUri,
   createCollectionsClient: () => createCollectionsClient,
   createConsumerCollectionsClient: () => createConsumerCollectionsClient,
   createConsumerWithdrawalsClient: () => createConsumerWithdrawalsClient,
   createFlurPartnerClient: () => createFlurPartnerClient,
   createHmacFetch: () => createHmacFetch,
   createMeOfflineClient: () => createMeOfflineClient,
+  createOfflinePaymentAuthorizationArtifactUri: () => createOfflinePaymentAuthorizationArtifactUri,
   createOfflineSettlementsClient: () => createOfflineSettlementsClient,
   createPartnerCollectionsClient: () => createPartnerCollectionsClient,
   createPartnerFundingClient: () => createPartnerFundingClient,
   createPartnerProfileAdminClient: () => createPartnerProfileAdminClient,
   createPassesClient: () => createPassesClient,
+  createReceiptArtifactUri: () => createReceiptArtifactUri,
   createReceiptsClient: () => createReceiptsClient,
+  decodeArtifactUri: () => decodeArtifactUri,
   decodeAuthorizationQR: () => decodeAuthorizationQR,
   decodeBase45: () => decodeBase45,
   decodePaymentRequestQR: () => decodePaymentRequestQR,
+  encodeArtifactUri: () => encodeArtifactUri,
   encodeAuthorizationQR: () => encodeAuthorizationQR,
   encodeBase45: () => encodeBase45,
   encodeNQR: () => encodeNQR,
@@ -158,6 +185,8 @@ __export(index_exports, {
   generateKeyPair: () => generateKeyPair,
   generateStaticQR: () => generateStaticQR,
   init: () => init,
+  isHardenedArtifactType: () => isHardenedArtifactType,
+  isKnownArtifactType: () => isKnownArtifactType,
   isPassWithinValidity: () => isPassWithinValidity,
   moneyMinorToNumber: () => moneyMinorToNumber,
   normalizeE164: () => normalizeE164,
@@ -168,6 +197,7 @@ __export(index_exports, {
   readTLV: () => readTLV,
   routingHint: () => routingHint,
   sign: () => sign,
+  signArtifact: () => signArtifact,
   signAuthorization: () => signAuthorization,
   signCanonical: () => signCanonical,
   signOAC: () => signOAC,
@@ -178,6 +208,8 @@ __export(index_exports, {
   signRedemption: () => signRedemption,
   signRequestHMAC: () => signRequestHMAC,
   verify: () => verify,
+  verifyArtifactSignature: () => verifyArtifactSignature,
+  verifyArtifactUri: () => verifyArtifactUri,
   verifyAuthorization: () => verifyAuthorization,
   verifyCanonical: () => verifyCanonical,
   verifyOAC: () => verifyOAC,
@@ -344,6 +376,13 @@ var AccountActivityItemSchema = import_zod.z.object({
   timestamp: IsoDateSchema
 });
 var AccountSummaryResponseSchema = import_zod.z.object({
+  /** Authenticated user's stable internal id. */
+  userId: UuidSchema,
+  /**
+   * 10-digit Nigeria Uniform Bank Account Number (NUBAN) allocated by the
+   * bank partner. `null` when the user has no partner-allocated account yet.
+   */
+  nuban: import_zod.z.string().regex(/^[0-9]{10}$/).nullable(),
   balance: import_zod.z.number().int(),
   currency: CurrencySchema,
   dailySendLimit: import_zod.z.number().int().nonnegative(),
@@ -3667,14 +3706,420 @@ function createPartnerProfileAdminClient(opts) {
     }
   };
 }
+
+// src/artifacts/envelope.ts
+var import_zod15 = require("zod");
+var FLUR_ARTIFACT_URI_SCHEME = "flur";
+var FLUR_ARTIFACT_VERSION = 1;
+var FLUR_ARTIFACT_URI_PREFIX = `${FLUR_ARTIFACT_URI_SCHEME}://v${FLUR_ARTIFACT_VERSION}/`;
+var ArtifactTypeRe = /^[a-z][a-z0-9_]{1,63}$/;
+var ArtifactHeaderSchema = import_zod15.z.object({
+  v: import_zod15.z.literal(FLUR_ARTIFACT_VERSION),
+  t: import_zod15.z.string().regex(ArtifactTypeRe, "invalid artifact type"),
+  iss: import_zod15.z.string().min(1).max(128),
+  kid: import_zod15.z.string().min(1).max(128),
+  iat: import_zod15.z.number().int().nonnegative(),
+  exp: import_zod15.z.number().int().positive().optional(),
+  nonce: import_zod15.z.string().min(8).max(64).regex(/^[A-Za-z0-9_-]+$/, "nonce must be url-safe")
+});
+var FlurArtifactError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "FlurArtifactError";
+  }
+  code;
+};
+function base64UrlEncode(bytes) {
+  let bin = "";
+  for (let i = 0; i < bytes.length; i++) bin += String.fromCharCode(bytes[i]);
+  const b64 = typeof btoa === "function" ? btoa(bin) : Buffer.from(bytes).toString("base64");
+  return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64UrlDecode(s) {
+  const pad = s.length % 4 === 0 ? "" : "=".repeat(4 - s.length % 4);
+  const b64 = s.replace(/-/g, "+").replace(/_/g, "/") + pad;
+  if (typeof atob === "function") {
+    const bin = atob(b64);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+    return out;
+  }
+  return new Uint8Array(Buffer.from(b64, "base64"));
+}
+function buildArtifactBody(input) {
+  if (!ArtifactTypeRe.test(input.type)) {
+    throw new FlurArtifactError(
+      `Invalid artifact type: ${input.type}`,
+      "INVALID_TYPE"
+    );
+  }
+  const iat = input.issuedAtSeconds ?? Math.floor(Date.now() / 1e3);
+  const header = {
+    v: FLUR_ARTIFACT_VERSION,
+    t: input.type,
+    iss: input.issuer,
+    kid: input.keyId,
+    iat,
+    ...input.expiresAtSeconds !== void 0 ? { exp: input.expiresAtSeconds } : {},
+    nonce: input.nonce
+  };
+  ArtifactHeaderSchema.parse(header);
+  return { ...header, data: input.data };
+}
+function signArtifact(body, privateKey) {
+  const sig = bytesToHex(sign(canonicalJSONBytes(body), privateKey));
+  return { body, sig };
+}
+function encodeArtifactUri(signed) {
+  const bodyBytes = canonicalJSONBytes(signed.body);
+  const bodyB64 = base64UrlEncode(bodyBytes);
+  const sigB64 = base64UrlEncode(hexToBytes(signed.sig));
+  return `${FLUR_ARTIFACT_URI_PREFIX}${signed.body.t}/${bodyB64}.${sigB64}`;
+}
+function decodeArtifactUri(uri) {
+  if (!uri.startsWith(FLUR_ARTIFACT_URI_PREFIX)) {
+    throw new FlurArtifactError(
+      `URI does not start with ${FLUR_ARTIFACT_URI_PREFIX}`,
+      "INVALID_URI"
+    );
+  }
+  const rest = uri.slice(FLUR_ARTIFACT_URI_PREFIX.length);
+  const slash = rest.indexOf("/");
+  if (slash <= 0) {
+    throw new FlurArtifactError("Missing artifact type segment", "INVALID_URI");
+  }
+  const type = rest.slice(0, slash);
+  const payload = rest.slice(slash + 1);
+  const dot = payload.indexOf(".");
+  if (dot <= 0 || dot === payload.length - 1) {
+    throw new FlurArtifactError(
+      "Missing body/signature separator",
+      "INVALID_URI"
+    );
+  }
+  if (!ArtifactTypeRe.test(type)) {
+    throw new FlurArtifactError(
+      `Invalid artifact type: ${type}`,
+      "INVALID_TYPE"
+    );
+  }
+  const bodyBytes = base64UrlDecode(payload.slice(0, dot));
+  const sigBytes = base64UrlDecode(payload.slice(dot + 1));
+  if (sigBytes.length !== 64) {
+    throw new FlurArtifactError(
+      `Signature must be 64 bytes, got ${sigBytes.length}`,
+      "INVALID_SIGNATURE"
+    );
+  }
+  let bodyJson;
+  try {
+    bodyJson = JSON.parse(new TextDecoder().decode(bodyBytes));
+  } catch {
+    throw new FlurArtifactError("Body is not valid JSON", "INVALID_BODY");
+  }
+  const headerOnly = ArtifactHeaderSchema.safeParse(bodyJson);
+  if (!headerOnly.success) {
+    throw new FlurArtifactError(
+      `Body header invalid: ${headerOnly.error.message}`,
+      "INVALID_BODY"
+    );
+  }
+  if (headerOnly.data.t !== type) {
+    throw new FlurArtifactError(
+      `URI type ${type} does not match body type ${headerOnly.data.t}`,
+      "TYPE_MISMATCH"
+    );
+  }
+  return {
+    type,
+    bodyBytes,
+    body: bodyJson,
+    sig: bytesToHex(sigBytes)
+  };
+}
+function verifyArtifactSignature(decoded, publicKey, options = {}) {
+  if (options.enforceExpiry !== false && decoded.body.exp !== void 0) {
+    const now = options.nowSeconds ?? Math.floor(Date.now() / 1e3);
+    if (decoded.body.exp < now) {
+      throw new FlurArtifactError("Artifact has expired", "EXPIRED");
+    }
+  }
+  return verify(decoded.bodyBytes, hexToBytes(decoded.sig), publicKey);
+}
+
+// src/artifacts/types.ts
+var import_zod16 = require("zod");
+var ARTIFACT_TYPES = {
+  OFFLINE_PAYMENT_AUTHORIZATION: "offline_payment_authorization",
+  RECEIPT: "receipt",
+  // --- stubs, schemas to be hardened in follow-ups ---
+  NQR_PAYMENT_REQUEST: "nqr_payment_request",
+  PAYMENT_INTENT: "payment_intent",
+  OFFLINE_CLAIM: "offline_claim",
+  SETTLEMENT_RECORD: "settlement_record",
+  REVERSAL_RECORD: "reversal_record",
+  LEDGER_JOURNAL_ENTRY: "ledger_journal_entry",
+  STATEMENT: "statement",
+  PASS: "pass",
+  IDENTITY: "identity"
+};
+var HexString4 = (length) => import_zod16.z.string().regex(
+  new RegExp(`^[0-9a-fA-F]{${length * 2}}$`),
+  `expected ${length}-byte hex string`
+);
+var OfflinePaymentAuthorizationArtifactSchema = import_zod16.z.object({
+  authorization: OfflinePaymentAuthorizationSchema
+});
+var ReceiptArtifactSchema = import_zod16.z.object({
+  receiptId: import_zod16.z.string().min(1).max(64),
+  paymentReference: import_zod16.z.string().min(1).max(64),
+  payerUserId: import_zod16.z.string().min(1).max(64).optional(),
+  payeeUserId: import_zod16.z.string().min(1).max(64),
+  amountKobo: import_zod16.z.number().int().positive(),
+  currency: import_zod16.z.literal("NGN"),
+  channel: import_zod16.z.enum(["online", "offline_reconciled", "pay_link", "nqr"]),
+  settledAtMs: import_zod16.z.number().int().positive(),
+  ledgerTxnId: import_zod16.z.string().min(1).max(64).optional(),
+  memo: import_zod16.z.string().max(140).optional(),
+  hashChainPrev: HexString4(32).optional()
+});
+var ShortId = import_zod16.z.string().min(1).max(64);
+var PositiveInt = import_zod16.z.number().int().positive();
+var NonNegativeInt = import_zod16.z.number().int().nonnegative();
+var Currency2 = import_zod16.z.literal("NGN");
+var Memo = import_zod16.z.string().max(140);
+var NqrPaymentRequestArtifactSchema = import_zod16.z.object({
+  requestId: ShortId,
+  payeeUserId: ShortId,
+  amountKobo: PositiveInt.optional(),
+  currency: Currency2,
+  memo: Memo.optional(),
+  expiresAtMs: PositiveInt.optional()
+});
+var PaymentIntentArtifactSchema = import_zod16.z.object({
+  intentId: ShortId,
+  payerUserId: ShortId,
+  payeeUserId: ShortId,
+  amountKobo: PositiveInt,
+  currency: Currency2,
+  idempotencyKey: ShortId,
+  createdAtMs: PositiveInt
+});
+var OfflineClaimArtifactSchema = import_zod16.z.object({
+  claimId: ShortId,
+  authorizationId: ShortId,
+  payeeUserId: ShortId,
+  claimedAmountKobo: PositiveInt,
+  currency: Currency2,
+  claimedAtMs: PositiveInt,
+  paymentReference: ShortId.optional()
+});
+var SettlementRecordArtifactSchema = import_zod16.z.object({
+  settlementId: ShortId,
+  ledgerTxnId: ShortId,
+  sourceRefType: import_zod16.z.enum([
+    "offline_authorization",
+    "offline_claim",
+    "transfer",
+    "pay_link"
+  ]),
+  sourceRefId: ShortId,
+  amountKobo: PositiveInt,
+  currency: Currency2,
+  settledAtMs: PositiveInt
+});
+var ReversalRecordArtifactSchema = import_zod16.z.object({
+  reversalId: ShortId,
+  originalTxnId: ShortId,
+  amountKobo: PositiveInt,
+  currency: Currency2,
+  reason: import_zod16.z.enum([
+    "user_dispute",
+    "fraud",
+    "duplicate",
+    "admin_correction",
+    "other"
+  ]),
+  reversedAtMs: PositiveInt,
+  memo: Memo.optional()
+});
+var LedgerJournalEntryArtifactSchema = import_zod16.z.object({
+  entryId: ShortId,
+  journalId: ShortId,
+  debitAccountId: ShortId,
+  creditAccountId: ShortId,
+  amountKobo: PositiveInt,
+  currency: Currency2,
+  postedAtMs: PositiveInt,
+  refType: ShortId.optional(),
+  refId: ShortId.optional()
+});
+var StatementArtifactSchema = import_zod16.z.object({
+  statementId: ShortId,
+  userId: ShortId,
+  periodStartMs: PositiveInt,
+  periodEndMs: PositiveInt,
+  openingBalanceKobo: import_zod16.z.number().int(),
+  closingBalanceKobo: import_zod16.z.number().int(),
+  transactionCount: NonNegativeInt,
+  currency: Currency2,
+  hashChainPrev: HexString4(32).optional()
+}).refine((v) => v.periodEndMs > v.periodStartMs, {
+  message: "periodEndMs must be greater than periodStartMs",
+  path: ["periodEndMs"]
+});
+var PassArtifactSchema = import_zod16.z.object({
+  passId: ShortId,
+  holderId: ShortId,
+  category: import_zod16.z.enum(["membership", "ticket", "loyalty", "access", "voucher"]),
+  title: import_zod16.z.string().min(1).max(120),
+  validFromMs: PositiveInt,
+  validUntilMs: PositiveInt.optional(),
+  metadata: import_zod16.z.record(
+    import_zod16.z.string().min(1).max(64),
+    import_zod16.z.union([import_zod16.z.string().max(280), import_zod16.z.number(), import_zod16.z.boolean()])
+  ).optional()
+}).refine(
+  (v) => v.validUntilMs === void 0 || v.validUntilMs > v.validFromMs,
+  {
+    message: "validUntilMs must be greater than validFromMs",
+    path: ["validUntilMs"]
+  }
+);
+var IdentityArtifactSchema = import_zod16.z.object({
+  attestationId: ShortId,
+  subjectId: ShortId,
+  claimType: import_zod16.z.enum([
+    "phone_verified",
+    "email_verified",
+    "bvn_verified",
+    "kyc_tier",
+    "age_band"
+  ]),
+  claimValueHash: HexString4(32),
+  attestedAtMs: PositiveInt
+});
+var ARTIFACT_BODY_SCHEMAS = {
+  [ARTIFACT_TYPES.OFFLINE_PAYMENT_AUTHORIZATION]: OfflinePaymentAuthorizationArtifactSchema,
+  [ARTIFACT_TYPES.RECEIPT]: ReceiptArtifactSchema,
+  [ARTIFACT_TYPES.NQR_PAYMENT_REQUEST]: NqrPaymentRequestArtifactSchema,
+  [ARTIFACT_TYPES.PAYMENT_INTENT]: PaymentIntentArtifactSchema,
+  [ARTIFACT_TYPES.OFFLINE_CLAIM]: OfflineClaimArtifactSchema,
+  [ARTIFACT_TYPES.SETTLEMENT_RECORD]: SettlementRecordArtifactSchema,
+  [ARTIFACT_TYPES.REVERSAL_RECORD]: ReversalRecordArtifactSchema,
+  [ARTIFACT_TYPES.LEDGER_JOURNAL_ENTRY]: LedgerJournalEntryArtifactSchema,
+  [ARTIFACT_TYPES.STATEMENT]: StatementArtifactSchema,
+  [ARTIFACT_TYPES.PASS]: PassArtifactSchema,
+  [ARTIFACT_TYPES.IDENTITY]: IdentityArtifactSchema
+};
+var HARDENED_ARTIFACT_TYPES = /* @__PURE__ */ new Set([
+  ARTIFACT_TYPES.OFFLINE_PAYMENT_AUTHORIZATION,
+  ARTIFACT_TYPES.RECEIPT,
+  ARTIFACT_TYPES.NQR_PAYMENT_REQUEST,
+  ARTIFACT_TYPES.PAYMENT_INTENT,
+  ARTIFACT_TYPES.OFFLINE_CLAIM,
+  ARTIFACT_TYPES.SETTLEMENT_RECORD,
+  ARTIFACT_TYPES.REVERSAL_RECORD,
+  ARTIFACT_TYPES.LEDGER_JOURNAL_ENTRY,
+  ARTIFACT_TYPES.STATEMENT,
+  ARTIFACT_TYPES.PASS,
+  ARTIFACT_TYPES.IDENTITY
+]);
+function isKnownArtifactType(t) {
+  return Object.values(ARTIFACT_TYPES).includes(t);
+}
+function isHardenedArtifactType(t) {
+  return HARDENED_ARTIFACT_TYPES.has(t);
+}
+
+// src/artifacts/codec.ts
+function createArtifactUri(input) {
+  if (!isKnownArtifactType(input.type)) {
+    throw new FlurArtifactError(
+      `Unknown artifact type: ${input.type}`,
+      "INVALID_TYPE"
+    );
+  }
+  if (!isHardenedArtifactType(input.type)) {
+    throw new FlurArtifactError(
+      `Artifact type ${input.type} is not yet hardened for emission`,
+      "INVALID_TYPE"
+    );
+  }
+  const schema = ARTIFACT_BODY_SCHEMAS[input.type];
+  const parsedData = schema.parse(input.data);
+  const body = buildArtifactBody({
+    type: input.type,
+    issuer: input.issuer,
+    keyId: input.keyId,
+    data: parsedData,
+    nonce: input.nonce,
+    issuedAtSeconds: input.issuedAtSeconds,
+    expiresAtSeconds: input.expiresAtSeconds
+  });
+  const signed = signArtifact(body, input.privateKey);
+  return { uri: encodeArtifactUri(signed), signed };
+}
+function verifyArtifactUri(uri, publicKey, options = {}) {
+  const decoded = decodeArtifactUri(uri);
+  if (!isKnownArtifactType(decoded.type)) {
+    throw new FlurArtifactError(
+      `Unknown artifact type: ${decoded.type}`,
+      "INVALID_TYPE"
+    );
+  }
+  if (!isHardenedArtifactType(decoded.type)) {
+    throw new FlurArtifactError(
+      `Artifact type ${decoded.type} is not yet hardened for verification`,
+      "INVALID_TYPE"
+    );
+  }
+  const schema = ARTIFACT_BODY_SCHEMAS[decoded.type];
+  const dataParsed = schema.safeParse(decoded.body.data);
+  if (!dataParsed.success) {
+    throw new FlurArtifactError(
+      `Artifact body invalid: ${dataParsed.error.message}`,
+      "INVALID_BODY"
+    );
+  }
+  const ok = verifyArtifactSignature(decoded, publicKey, options);
+  if (!ok) {
+    throw new FlurArtifactError(
+      "Artifact signature verification failed",
+      "INVALID_SIGNATURE"
+    );
+  }
+  return {
+    type: decoded.type,
+    body: decoded.body,
+    sig: decoded.sig,
+    decoded
+  };
+}
+function createReceiptArtifactUri(input) {
+  return createArtifactUri({
+    ...input,
+    type: ARTIFACT_TYPES.RECEIPT
+  });
+}
+function createOfflinePaymentAuthorizationArtifactUri(input) {
+  return createArtifactUri({
+    ...input,
+    type: ARTIFACT_TYPES.OFFLINE_PAYMENT_AUTHORIZATION
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACCOUNT_STATUSES,
   ACCOUNT_TYPES,
   ADDITIONAL_DATA_SUBFIELD,
+  ARTIFACT_BODY_SCHEMAS,
+  ARTIFACT_TYPES,
   AccountMembershipSchema,
   AccountSchema,
   ApiCredentialPublicSchema,
+  ArtifactHeaderSchema,
   COLLECTION_INTENT_STATUSES,
   COLLECTION_PAYMENT_STATUSES,
   CUSTODIAL_MODES,
@@ -3699,14 +4144,21 @@ function createPartnerProfileAdminClient(opts) {
   EnableOfflineInputSchema,
   EnableOfflineResultSchema,
   FIELD,
+  FLUR_ARTIFACT_URI_PREFIX,
+  FLUR_ARTIFACT_URI_SCHEME,
+  FLUR_ARTIFACT_VERSION,
   FlurApiError,
+  FlurArtifactError,
   FlurCapExceededError,
   FlurClient,
   FlurError,
   FlurExpiredError,
   FlurReplayError,
+  HARDENED_ARTIFACT_TYPES,
+  IdentityArtifactSchema,
   IngestFundingResultSchema,
   IssueOACInputSchema,
+  LedgerJournalEntryArtifactSchema,
   ListPayoutDestinationsResultSchema,
   MEMBERSHIP_ROLES,
   MERCHANT_PAYOUT_STATUSES,
@@ -3717,11 +4169,14 @@ function createPartnerProfileAdminClient(opts) {
   NGN_CURRENCY_CODE,
   NG_COUNTRY_CODE,
   NQRParseError,
+  NqrPaymentRequestArtifactSchema,
   OACSchema,
   OAC_DEFAULT_CUMULATIVE_KOBO,
   OAC_DEFAULT_PER_TX_KOBO,
   OAC_DEFAULT_VALIDITY_MS,
+  OfflineClaimArtifactSchema,
   OfflineHoldRecordSchema,
+  OfflinePaymentAuthorizationArtifactSchema,
   OfflinePaymentAuthorizationSchema,
   OfflinePaymentRequestSchema,
   OfflineStateResultSchema,
@@ -3740,10 +4195,12 @@ function createPartnerProfileAdminClient(opts) {
   PartnerFundingEventInputSchema,
   PartnerFundingSchema,
   PartnerProfileSchema,
+  PassArtifactSchema,
   PassMetadataSchema,
   PassSchema,
   PayCollectionInputSchema,
   PaymentClaimSchema,
+  PaymentIntentArtifactSchema,
   PayoutDestinationSchema,
   PayoutEventInputSchema,
   ProviderEventInputSchema,
@@ -3752,22 +4209,29 @@ function createPartnerProfileAdminClient(opts) {
   RECEIPT_CHANNELS,
   RECEIPT_KINDS,
   REPLAY_WINDOW_MS,
+  ReceiptArtifactSchema,
   ReceiptPayloadSchema,
   ReceiptSchema,
   ReconciliationReportSchema,
   RecordPayoutEventResultSchema,
   RedemptionSchema,
   RegisterDeviceKeyInputSchema,
+  ReversalRecordArtifactSchema,
   RevokeDeviceKeyInputSchema,
   SETTLEMENT_SCHEDULES,
   SettleResponseSchema,
+  SettlementRecordArtifactSchema,
   SettlementSchema,
   SignedConsumerOACSchema,
+  StatementArtifactSchema,
   UpsertMerchantProfileInputSchema,
   UpsertPartnerProfileInputSchema,
   WITHDRAWAL_STATES,
   WithdrawalSchema,
+  base64UrlDecode,
+  base64UrlEncode,
   bodySha256Hex,
+  buildArtifactBody,
   buildAuthorization,
   buildOAC,
   buildPass,
@@ -3783,21 +4247,26 @@ function createPartnerProfileAdminClient(opts) {
   crc16ccittHex,
   createAccountsClient,
   createApiCredentialsAdminClient,
+  createArtifactUri,
   createCollectionsClient,
   createConsumerCollectionsClient,
   createConsumerWithdrawalsClient,
   createFlurPartnerClient,
   createHmacFetch,
   createMeOfflineClient,
+  createOfflinePaymentAuthorizationArtifactUri,
   createOfflineSettlementsClient,
   createPartnerCollectionsClient,
   createPartnerFundingClient,
   createPartnerProfileAdminClient,
   createPassesClient,
+  createReceiptArtifactUri,
   createReceiptsClient,
+  decodeArtifactUri,
   decodeAuthorizationQR,
   decodeBase45,
   decodePaymentRequestQR,
+  encodeArtifactUri,
   encodeAuthorizationQR,
   encodeBase45,
   encodeNQR,
@@ -3807,6 +4276,8 @@ function createPartnerProfileAdminClient(opts) {
   generateKeyPair,
   generateStaticQR,
   init,
+  isHardenedArtifactType,
+  isKnownArtifactType,
   isPassWithinValidity,
   moneyMinorToNumber,
   normalizeE164,
@@ -3817,6 +4288,7 @@ function createPartnerProfileAdminClient(opts) {
   readTLV,
   routingHint,
   sign,
+  signArtifact,
   signAuthorization,
   signCanonical,
   signOAC,
@@ -3827,6 +4299,8 @@ function createPartnerProfileAdminClient(opts) {
   signRedemption,
   signRequestHMAC,
   verify,
+  verifyArtifactSignature,
+  verifyArtifactUri,
   verifyAuthorization,
   verifyCanonical,
   verifyOAC,