@bitgo-beta/utxo-ord
Version:
Utilities for building ordinals with BitGo utxo-lib
254 lines (238 loc) • 29.1 kB
JavaScript
;
/*
This file contains code for creating an output layouts for transactions that pass on inscriptions.
When passing on an inscription, we want to satisfy a few constraints:
* All outputs should be larger than a minimal value (dust limit)
* The sum of all output values needs to be less than the input to cover the transaction fee.
* The output containing the inscription should be as small as possible, but large enough to
contain the inscription.
To keep the inscription output small, we can pad the satoshi range preceding and following the range
with change outputs, which have a minimal size and incur a fee cost.
Broadly speaking, there are four scenarios:
(1) Small inscription input that has just enough value to pay for fee and a single inscription
output (u0). No padding outputs.
┌────────┬────────┐
│ │ u0 │
│ r ┼ │
│ ├────────┘
│ │ fee
└────────┘
(2) Large inscription input with inscription close to start of input.
Inscription output followed by change output (u1) padding the remaining value.
┌────────┬────────┐
│ │ u0 │
│ r ┼ │
│ ├────────┤
│ │ u1 │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ ├────────┘
│ │
│ │ fee
│ │
└────────┘
(3) Large inscription input with inscription close to end of input.
Change output padding start followed by inscription output.
(TODO)
┌────────┬────────┐
│ │ u0 │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ │ │
│ ├────────┤
│ r ┼ │
│ │ u1 │
│ ├────────┘
│ │
│ │ fee
│ │
└────────┘
(4) Large inscription input with inscription in the middle.
Inscription input (u1) with padding on both sides (u0 and u2)
(TODO)
┌────────┬────────┐
│ │ u0 │
│ │ │
│ │ │
│ │ │
│ │ │
│ ├────────┤
│ │ u1 │
│ r ┼ │
│ ├────────┤
│ │ u2 │
│ │ │
│ │ │
│ │ │
│ ├────────┘
│ │
│ │ fee
│ │
└────────┘
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.findOutputLayout = exports.getOrdOutputsForLayout = exports.toParameters = exports.toArray = exports.Constraint = void 0;
const SatRange_1 = require("./SatRange");
/**
* A range constraint
*/
class Constraint {
/**
* @param minValue - inclusive
* @param maxValue - inclusive
*/
constructor(minValue, maxValue) {
this.minValue = minValue;
this.maxValue = maxValue;
if (minValue < 0 || maxValue < minValue) {
throw new Error(`invalid constraint [${minValue}, ${maxValue}]`);
}
}
/** @return true iff value satisfies constraint */
check(v) {
return new SatRange_1.SatRange(this.minValue, this.maxValue).isSupersetOf(v);
}
}
exports.Constraint = Constraint;
Constraint.ZERO = new Constraint(BigInt(0), BigInt(0));
/** infinity for all practical purposes */
Constraint.MAXSAT = BigInt(21e14);
/** @return canonical sequence of parameters */
function toArray(p) {
return [p.firstChangeOutput, p.inscriptionOutput, p.secondChangeOutput, p.feeOutput];
}
exports.toArray = toArray;
function toParameters(firstChangeOutput, inscriptionOutput, secondChangeOutput, feeOutput) {
return {
firstChangeOutput,
inscriptionOutput,
secondChangeOutput,
feeOutput,
};
}
exports.toParameters = toParameters;
/**
* Translates a layout into OrdOutputs. Absent outputs are set to `null`.
*
* @param inscriptionInput
* @param layout
* @return OrdOutputs for layout
*/
function getOrdOutputsForLayout(inscriptionInput, layout) {
const outputs = inscriptionInput.splitAllWithParams(toArray(layout), { exact: true, allowZero: true });
if (outputs.length !== 4) {
throw new Error(`unexpected result`);
}
return toParameters(...outputs);
}
exports.getOrdOutputsForLayout = getOrdOutputsForLayout;
/**
* @param layout
* @return output sum (including fee output) for layout.
*/
function getLayoutSum(layout) {
return toArray(layout).reduce((a, b) => a + b, BigInt(0));
}
/**
* @param inscriptionInput
* @param layout
* @param constraints
* @return true iff layout satisfies constraints
*/
function check(inscriptionInput, layout, constraints) {
var _a;
if (constraints.firstChangeOutput.check(layout.firstChangeOutput) &&
constraints.inscriptionOutput.check(layout.inscriptionOutput) &&
constraints.secondChangeOutput.check(layout.secondChangeOutput) &&
constraints.feeOutput.check(layout.feeOutput) &&
getLayoutSum(layout) === inscriptionInput.value) {
/* make sure inscription actually lies on the inscriptionOutput */
const outputs = getOrdOutputsForLayout(inscriptionInput, layout);
return ((_a = outputs.inscriptionOutput) === null || _a === void 0 ? void 0 : _a.ordinals.length) === 1;
}
return false;
}
/**
* Solves the constraints defined in _p_ to produce a layout by expanding a parameter.
* Currently only works with one expandable parameter.
* @param total - the total input sum
* @param p - the constraint parameters.
* @return OutputLayout
*/
function toOutputLayout(total, p) {
const fixed = Object.values(p).filter((v) => v.minValue === v.maxValue);
const expandable = Object.values(p).filter((v) => v.minValue !== v.maxValue);
if (expandable.length === 0) {
return Object.fromEntries(Object.entries(p).map(([k, v]) => [k, v.minValue]));
}
if (expandable.length === 1) {
const sumFixed = fixed.reduce((sum, e) => sum + e.minValue, BigInt(0));
const remainder = total - sumFixed;
if (remainder < 0) {
return;
}
for (const k in p) {
if (p[k] === expandable[0]) {
return toOutputLayout(total, { ...p, [k]: new Constraint(remainder, remainder) });
}
}
throw new Error(`illegal state`);
}
throw new Error(`cannot expand more than one constraint`);
}
/**
* @param inscriptionInput
* @param minChangeOutput
* @param maxChangeOutput
* @param minInscriptionOutput
* @param maxInscriptionOutput
* @param feeFixed
* @param feePerOutput
* @return a solution that satisfies constraints. If no solution can be found, return `undefined`.
*/
function findOutputLayout(inscriptionInput, { minChangeOutput, maxChangeOutput, minInscriptionOutput, maxInscriptionOutput, feeFixed, feePerOutput }) {
if (inscriptionInput.ordinals.length !== 1) {
throw new Error(`unexpected ordinal count`);
}
if (inscriptionInput.ordinals[0].size() !== BigInt(1)) {
throw new Error(`only single-satoshi inscriptions are supported`);
}
function feeConstraintForOutputCount(n) {
const fee = feeFixed + feePerOutput * BigInt(n);
return new Constraint(fee, fee);
}
const fixedZero = Constraint.ZERO;
const expandableChangePadding = new Constraint(minChangeOutput, maxChangeOutput);
const expandableInscriptionConstraint = new Constraint(minInscriptionOutput, maxInscriptionOutput);
const fixedMinInscriptionConstraint = new Constraint(minInscriptionOutput, minInscriptionOutput);
const fixedMaxInscriptionConstraint = new Constraint(maxInscriptionOutput, maxInscriptionOutput);
const candidates = [
toParameters(fixedZero, expandableInscriptionConstraint, fixedZero, feeConstraintForOutputCount(1)),
toParameters(fixedZero, fixedMinInscriptionConstraint, expandableChangePadding, feeConstraintForOutputCount(2)),
toParameters(fixedZero, fixedMaxInscriptionConstraint, expandableChangePadding, feeConstraintForOutputCount(2)),
/* TODO(BG-68135): search solution space with change padding at the start */
];
for (const candidate of candidates) {
const result = toOutputLayout(inscriptionInput.value, candidate);
if (!result) {
continue;
}
if (check(inscriptionInput, result, candidate)) {
return result;
}
}
}
exports.findOutputLayout = findOutputLayout;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"OutputLayout.js","sourceRoot":"","sources":["../../src/OutputLayout.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n\nThis file contains code for creating an output layouts for transactions that pass on inscriptions.\n\nWhen passing on an inscription, we want to satisfy a few constraints:\n\n* All outputs should be larger than a minimal value (dust limit)\n* The sum of all output values needs to be less than the input to cover the transaction fee.\n* The output containing the inscription should be as small as possible, but large enough to\n  contain the inscription.\n\nTo keep the inscription output small, we can pad the satoshi range preceding and following the range\nwith change outputs, which have a minimal size and incur a fee cost.\n\n\nBroadly speaking, there are four scenarios:\n\n(1) Small inscription input that has just enough value to pay for fee and a single inscription\n    output (u0). No padding outputs.\n    ┌────────┬────────┐\n    │        │ u0     │\n    │      r ┼        │\n    │        ├────────┘\n    │        │ fee\n    └────────┘\n\n\n(2) Large inscription input with inscription close to start of input.\n    Inscription output followed by change output (u1) padding the remaining value.\n\n    ┌────────┬────────┐\n    │        │ u0     │\n    │      r ┼        │\n    │        ├────────┤\n    │        │ u1     │\n    │        │        │\n    │        │        │\n    │        │        │\n    │        │        │\n    │        │        │\n    │        │        │\n    │        │        │\n    │        │        │\n    │        │        │\n    │        ├────────┘\n    │        │\n    │        │ fee\n    │        │\n    └────────┘\n\n\n(3) Large inscription input with inscription close to end of input.\n    Change output padding start followed by inscription output.\n    (TODO)\n\n    ┌────────┬────────┐\n    │        │ u0     │\n    │        │        │\n    │        │        │\n    │        │        │\n    │        │        │\n    │        │        │\n    │        │        │\n    │        │        │\n    │        │        │\n    │        ├────────┤\n    │      r ┼        │\n    │        │ u1     │\n    │        ├────────┘\n    │        │\n    │        │ fee\n    │        │\n    └────────┘\n\n\n(4) Large inscription input with inscription in the middle.\n    Inscription input (u1) with padding on both sides (u0 and u2)\n    (TODO)\n\n    ┌────────┬────────┐\n    │        │ u0     │\n    │        │        │\n    │        │        │\n    │        │        │\n    │        │        │\n    │        ├────────┤\n    │        │ u1     │\n    │      r ┼        │\n    │        ├────────┤\n    │        │ u2     │\n    │        │        │\n    │        │        │\n    │        │        │\n    │        ├────────┘\n    │        │\n    │        │ fee\n    │        │\n    └────────┘\n */\n\nimport { OrdOutput } from './OrdOutput';\nimport { SatRange } from './SatRange';\n\n/**\n * A range constraint\n */\nexport class Constraint {\n  /**\n   * @param minValue - inclusive\n   * @param maxValue - inclusive\n   */\n  constructor(public minValue: bigint, public maxValue: bigint) {\n    if (minValue < 0 || maxValue < minValue) {\n      throw new Error(`invalid constraint [${minValue}, ${maxValue}]`);\n    }\n  }\n\n  /** @return true iff value satisfies constraint */\n  check(v: bigint): boolean {\n    return new SatRange(this.minValue, this.maxValue).isSupersetOf(v);\n  }\n\n  static ZERO = new Constraint(BigInt(0), BigInt(0));\n  /** infinity for all practical purposes */\n  static MAXSAT = BigInt(21e14);\n}\n\ntype Parameters<T> = {\n  /** Padding preceding the inscription output */\n  firstChangeOutput: T;\n  /** The inscription output that will inherit the input inscription */\n  inscriptionOutput: T;\n  /** Padding following the inscription output */\n  secondChangeOutput: T;\n  /** Not a real output, used only to simplify calculations */\n  feeOutput: T;\n};\n\n/** @return canonical sequence of parameters */\nexport function toArray<T>(p: Parameters<T>): [T, T, T, T] {\n  return [p.firstChangeOutput, p.inscriptionOutput, p.secondChangeOutput, p.feeOutput];\n}\n\nexport function toParameters<T>(\n  firstChangeOutput: T,\n  inscriptionOutput: T,\n  secondChangeOutput: T,\n  feeOutput: T\n): Parameters<T> {\n  return {\n    firstChangeOutput,\n    inscriptionOutput,\n    secondChangeOutput,\n    feeOutput,\n  };\n}\n\n/** A finished output layout */\nexport type OutputLayout = Parameters<bigint>;\n\n/**\n * Translates a layout into OrdOutputs. Absent outputs are set to `null`.\n *\n * @param inscriptionInput\n * @param layout\n * @return OrdOutputs for layout\n */\nexport function getOrdOutputsForLayout(\n  inscriptionInput: OrdOutput,\n  layout: OutputLayout\n): Parameters<OrdOutput | null> {\n  const outputs = inscriptionInput.splitAllWithParams(toArray(layout), { exact: true, allowZero: true });\n  if (outputs.length !== 4) {\n    throw new Error(`unexpected result`);\n  }\n  type T = OrdOutput | null;\n  return toParameters(...(outputs as [T, T, T, T]));\n}\n\n/**\n * @param layout\n * @return output sum (including fee output) for layout.\n */\nfunction getLayoutSum(layout: OutputLayout): bigint {\n  return toArray(layout).reduce((a, b) => a + b, BigInt(0));\n}\n\n/**\n * @param inscriptionInput\n * @param layout\n * @param constraints\n * @return true iff layout satisfies constraints\n */\nfunction check(inscriptionInput: OrdOutput, layout: OutputLayout, constraints: Parameters<Constraint>): boolean {\n  if (\n    constraints.firstChangeOutput.check(layout.firstChangeOutput) &&\n    constraints.inscriptionOutput.check(layout.inscriptionOutput) &&\n    constraints.secondChangeOutput.check(layout.secondChangeOutput) &&\n    constraints.feeOutput.check(layout.feeOutput) &&\n    getLayoutSum(layout) === inscriptionInput.value\n  ) {\n    /* make sure inscription actually lies on the inscriptionOutput */\n    const outputs = getOrdOutputsForLayout(inscriptionInput, layout);\n    return outputs.inscriptionOutput?.ordinals.length === 1;\n  }\n\n  return false;\n}\n\n/**\n * Solves the constraints defined in _p_ to produce a layout by expanding a parameter.\n * Currently only works with one expandable parameter.\n * @param total - the total input sum\n * @param p - the constraint parameters.\n * @return OutputLayout\n */\nfunction toOutputLayout(total: bigint, p: Parameters<Constraint>): OutputLayout | undefined {\n  const fixed = Object.values(p).filter((v) => v.minValue === v.maxValue);\n  const expandable = Object.values(p).filter((v) => v.minValue !== v.maxValue);\n  if (expandable.length === 0) {\n    return Object.fromEntries(Object.entries(p).map(([k, v]) => [k, v.minValue])) as OutputLayout;\n  }\n\n  if (expandable.length === 1) {\n    const sumFixed = fixed.reduce((sum, e) => sum + e.minValue, BigInt(0));\n    const remainder = total - sumFixed;\n    if (remainder < 0) {\n      return;\n    }\n    for (const k in p) {\n      if (p[k as keyof Parameters<unknown>] === expandable[0]) {\n        return toOutputLayout(total, { ...p, [k]: new Constraint(remainder, remainder) });\n      }\n    }\n    throw new Error(`illegal state`);\n  }\n\n  throw new Error(`cannot expand more than one constraint`);\n}\n\n/**\n * High-level constraints for output layout\n */\nexport type SearchParams = {\n  minChangeOutput: bigint;\n  maxChangeOutput: bigint;\n  minInscriptionOutput: bigint;\n  maxInscriptionOutput: bigint;\n  feeFixed: bigint;\n  feePerOutput: bigint;\n};\n\n/**\n * @param inscriptionInput\n * @param minChangeOutput\n * @param maxChangeOutput\n * @param minInscriptionOutput\n * @param maxInscriptionOutput\n * @param feeFixed\n * @param feePerOutput\n * @return a solution that satisfies constraints. If no solution can be found, return `undefined`.\n */\nexport function findOutputLayout(\n  inscriptionInput: OrdOutput,\n  { minChangeOutput, maxChangeOutput, minInscriptionOutput, maxInscriptionOutput, feeFixed, feePerOutput }: SearchParams\n): OutputLayout | undefined {\n  if (inscriptionInput.ordinals.length !== 1) {\n    throw new Error(`unexpected ordinal count`);\n  }\n  if (inscriptionInput.ordinals[0].size() !== BigInt(1)) {\n    throw new Error(`only single-satoshi inscriptions are supported`);\n  }\n  function feeConstraintForOutputCount(n: number) {\n    const fee = feeFixed + feePerOutput * BigInt(n);\n    return new Constraint(fee, fee);\n  }\n\n  const fixedZero = Constraint.ZERO;\n  const expandableChangePadding = new Constraint(minChangeOutput, maxChangeOutput);\n  const expandableInscriptionConstraint = new Constraint(minInscriptionOutput, maxInscriptionOutput);\n  const fixedMinInscriptionConstraint = new Constraint(minInscriptionOutput, minInscriptionOutput);\n  const fixedMaxInscriptionConstraint = new Constraint(maxInscriptionOutput, maxInscriptionOutput);\n\n  const candidates = [\n    toParameters(fixedZero, expandableInscriptionConstraint, fixedZero, feeConstraintForOutputCount(1)),\n    toParameters(fixedZero, fixedMinInscriptionConstraint, expandableChangePadding, feeConstraintForOutputCount(2)),\n    toParameters(fixedZero, fixedMaxInscriptionConstraint, expandableChangePadding, feeConstraintForOutputCount(2)),\n    /* TODO(BG-68135): search solution space with change padding at the start */\n  ];\n\n  for (const candidate of candidates) {\n    const result = toOutputLayout(inscriptionInput.value, candidate);\n    if (!result) {\n      continue;\n    }\n    if (check(inscriptionInput, result, candidate)) {\n      return result;\n    }\n  }\n}\n"]}