@buildonspark/spark-sdk 0.0.15 → 0.0.17

package/src/graphql/objects/index.ts

@@ -0,0 +1,67 @@
+export { default as BitcoinNetwork } from "./BitcoinNetwork.js";
+export { default as CompleteCoopExitInput } from "./CompleteCoopExitInput.js";
+export { default as CompleteCoopExitOutput } from "./CompleteCoopExitOutput.js";
+export { default as CompleteLeavesSwapInput } from "./CompleteLeavesSwapInput.js";
+export { default as CompleteLeavesSwapOutput } from "./CompleteLeavesSwapOutput.js";
+export { default as CompleteSeedReleaseInput } from "./CompleteSeedReleaseInput.js";
+export { default as CompleteSeedReleaseOutput } from "./CompleteSeedReleaseOutput.js";
+export { default as Connection } from "./Connection.js";
+export { default as CoopExitFeeEstimateInput } from "./CoopExitFeeEstimateInput.js";
+export { default as CoopExitFeeEstimateOutput } from "./CoopExitFeeEstimateOutput.js";
+export {
+  default as CoopExitRequest,
+  getCoopExitRequestQuery,
+} from "./CoopExitRequest.js";
+export { default as CurrencyAmount } from "./CurrencyAmount.js";
+export { default as CurrencyUnit } from "./CurrencyUnit.js";
+export { default as Entity } from "./Entity.js";
+export { default as GetChallengeInput } from "./GetChallengeInput.js";
+export { default as GetChallengeOutput } from "./GetChallengeOutput.js";
+export { default as Invoice } from "./Invoice.js";
+export { default as Leaf } from "./Leaf.js";
+export { default as LeavesSwapFeeEstimateInput } from "./LeavesSwapFeeEstimateInput.js";
+export { default as LeavesSwapFeeEstimateOutput } from "./LeavesSwapFeeEstimateOutput.js";
+export {
+  getLeavesSwapRequestQuery,
+  default as LeavesSwapRequest,
+} from "./LeavesSwapRequest.js";
+export { default as LightningReceiveFeeEstimateInput } from "./LightningReceiveFeeEstimateInput.js";
+export { default as LightningReceiveFeeEstimateOutput } from "./LightningReceiveFeeEstimateOutput.js";
+export {
+  getLightningReceiveRequestQuery,
+  default as LightningReceiveRequest,
+} from "./LightningReceiveRequest.js";
+export { default as LightningReceiveRequestStatus } from "./LightningReceiveRequestStatus.js";
+export { default as LightningSendFeeEstimateInput } from "./LightningSendFeeEstimateInput.js";
+export { default as LightningSendFeeEstimateOutput } from "./LightningSendFeeEstimateOutput.js";
+export {
+  getLightningSendRequestQuery,
+  default as LightningSendRequest,
+} from "./LightningSendRequest.js";
+export { default as LightningSendRequestStatus } from "./LightningSendRequestStatus.js";
+export { default as NotifyReceiverTransferInput } from "./NotifyReceiverTransferInput.js";
+export { default as PageInfo } from "./PageInfo.js";
+export { default as Provider } from "./Provider.js";
+export { default as RequestCoopExitInput } from "./RequestCoopExitInput.js";
+export { default as RequestCoopExitOutput } from "./RequestCoopExitOutput.js";
+export { default as RequestLeavesSwapInput } from "./RequestLeavesSwapInput.js";
+export { default as RequestLeavesSwapOutput } from "./RequestLeavesSwapOutput.js";
+export { default as RequestLightningReceiveInput } from "./RequestLightningReceiveInput.js";
+export { default as RequestLightningReceiveOutput } from "./RequestLightningReceiveOutput.js";
+export { default as RequestLightningSendInput } from "./RequestLightningSendInput.js";
+export { default as RequestLightningSendOutput } from "./RequestLightningSendOutput.js";
+export { default as SparkCoopExitRequestStatus } from "./SparkCoopExitRequestStatus.js";
+export { default as SparkLeavesSwapRequestStatus } from "./SparkLeavesSwapRequestStatus.js";
+export { default as SparkTransferToLeavesConnection } from "./SparkTransferToLeavesConnection.js";
+export {
+  getSparkWalletUserQuery,
+  default as SparkWalletUser,
+} from "./SparkWalletUser.js";
+export { default as StartSeedReleaseInput } from "./StartSeedReleaseInput.js";
+export { default as SwapLeaf } from "./SwapLeaf.js";
+export { default as Transfer } from "./Transfer.js";
+export { default as UserLeafInput } from "./UserLeafInput.js";
+export { default as VerifyChallengeInput } from "./VerifyChallengeInput.js";
+export { default as VerifyChallengeOutput } from "./VerifyChallengeOutput.js";
+export { default as WalletUserIdentityPublicKeyInput } from "./WalletUserIdentityPublicKeyInput.js";
+export { default as WalletUserIdentityPublicKeyOutput } from "./WalletUserIdentityPublicKeyOutput.js";

package/src/graphql/queries/CoopExitFeeEstimate.ts

@@ -0,0 +1,18 @@
+import { FRAGMENT as CoopExitFeeEstimateOutputFragment } from "../objects/CoopExitFeeEstimateOutput.js";
+
+export const CoopExitFeeEstimate = `
+  query CoopExitFeeEstimate(
+    $leaf_external_ids: [UUID!]!
+    $withdrawal_address: String!
+  ) {
+    coop_exit_fee_estimate(
+      input: {
+        leaf_external_ids: $leaf_external_ids
+        withdrawal_address: $withdrawal_address
+      }
+    ) {
+      ...CoopExitFeeEstimateOutputFragment
+    }
+  }
+  ${CoopExitFeeEstimateOutputFragment}
+`;

package/src/graphql/queries/CurrentUser.ts

@@ -0,0 +1,10 @@
+import { FRAGMENT as SparkWalletUserFragment } from "../objects/SparkWalletUser.js";
+
+export const CurrentUser = `
+  query CurrentUser {
+    current_user {
+      ...SparkWalletUserFragment
+    }
+  }
+  ${SparkWalletUserFragment}
+`;

package/src/graphql/queries/LightningReceiveFeeEstimate.ts

@@ -0,0 +1,18 @@
+import { FRAGMENT as LightningReceiveFeeEstimateOutputFragment } from "../objects/LightningReceiveFeeEstimateOutput.js";
+
+export const LightningReceiveFeeEstimate = `
+  query LightningReceiveFeeEstimate(
+    $network: BitcoinNetwork!
+    $amount_sats: Long!
+  ) {
+    lightning_receive_fee_estimate(
+      input: {
+        network: $network
+        amount_sats: $amount_sats
+      }
+    ) {
+      ...LightningReceiveFeeEstimateOutputFragment
+    }
+  }
+  ${LightningReceiveFeeEstimateOutputFragment}
+`;

package/src/graphql/queries/LightningSendFeeEstimate.ts

@@ -0,0 +1,16 @@
+import { FRAGMENT as LightningSendFeeEstimateOutputFragment } from "../objects/LightningSendFeeEstimateOutput.js";
+
+export const LightningSendFeeEstimate = `
+  query LightningSendFeeEstimate(
+    $encoded_invoice: String!
+  ) {
+    lightning_send_fee_estimate(
+      input: {
+        encoded_invoice: $encoded_invoice
+      }
+    ) {
+      ...LightningSendFeeEstimateOutputFragment
+    }
+  }
+  ${LightningSendFeeEstimateOutputFragment}
+`;

package/src/proto/common.ts

@@ -0,0 +1,431 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.6.1
+//   protoc               v5.29.3
+// source: common.proto
+
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+
+export const protobufPackage = "common";
+
+export enum SignatureIntent {
+  CREATION = 0,
+  TRANSFER = 1,
+  AGGREGATE = 2,
+  REFRESH = 3,
+  EXTEND = 4,
+  UNRECOGNIZED = -1,
+}
+
+export function signatureIntentFromJSON(object: any): SignatureIntent {
+  switch (object) {
+    case 0:
+    case "CREATION":
+      return SignatureIntent.CREATION;
+    case 1:
+    case "TRANSFER":
+      return SignatureIntent.TRANSFER;
+    case 2:
+    case "AGGREGATE":
+      return SignatureIntent.AGGREGATE;
+    case 3:
+    case "REFRESH":
+      return SignatureIntent.REFRESH;
+    case 4:
+    case "EXTEND":
+      return SignatureIntent.EXTEND;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return SignatureIntent.UNRECOGNIZED;
+  }
+}
+
+export function signatureIntentToJSON(object: SignatureIntent): string {
+  switch (object) {
+    case SignatureIntent.CREATION:
+      return "CREATION";
+    case SignatureIntent.TRANSFER:
+      return "TRANSFER";
+    case SignatureIntent.AGGREGATE:
+      return "AGGREGATE";
+    case SignatureIntent.REFRESH:
+      return "REFRESH";
+    case SignatureIntent.EXTEND:
+      return "EXTEND";
+    case SignatureIntent.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+/** A map from a string to a bytes. It's a workaround to have map arrays in proto. */
+export interface PackageMap {
+  packages: { [key: string]: Uint8Array };
+}
+
+export interface PackageMap_PackagesEntry {
+  key: string;
+  value: Uint8Array;
+}
+
+/**
+ * A commitment for frost signing.
+ * It's a pair of public keys (points) in secp256k1 curve.
+ */
+export interface SigningCommitment {
+  /** The public key for hiding. 33 bytes. */
+  hiding: Uint8Array;
+  /** The public key for binding. 33 bytes. */
+  binding: Uint8Array;
+}
+
+export interface SigningResult {
+  signatureShare: Uint8Array;
+}
+
+function createBasePackageMap(): PackageMap {
+  return { packages: {} };
+}
+
+export const PackageMap: MessageFns<PackageMap> = {
+  encode(message: PackageMap, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    Object.entries(message.packages).forEach(([key, value]) => {
+      PackageMap_PackagesEntry.encode({ key: key as any, value }, writer.uint32(10).fork()).join();
+    });
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): PackageMap {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePackageMap();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          const entry1 = PackageMap_PackagesEntry.decode(reader, reader.uint32());
+          if (entry1.value !== undefined) {
+            message.packages[entry1.key] = entry1.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PackageMap {
+    return {
+      packages: isObject(object.packages)
+        ? Object.entries(object.packages).reduce<{ [key: string]: Uint8Array }>((acc, [key, value]) => {
+          acc[key] = bytesFromBase64(value as string);
+          return acc;
+        }, {})
+        : {},
+    };
+  },
+
+  toJSON(message: PackageMap): unknown {
+    const obj: any = {};
+    if (message.packages) {
+      const entries = Object.entries(message.packages);
+      if (entries.length > 0) {
+        obj.packages = {};
+        entries.forEach(([k, v]) => {
+          obj.packages[k] = base64FromBytes(v);
+        });
+      }
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<PackageMap>): PackageMap {
+    return PackageMap.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<PackageMap>): PackageMap {
+    const message = createBasePackageMap();
+    message.packages = Object.entries(object.packages ?? {}).reduce<{ [key: string]: Uint8Array }>(
+      (acc, [key, value]) => {
+        if (value !== undefined) {
+          acc[key] = value;
+        }
+        return acc;
+      },
+      {},
+    );
+    return message;
+  },
+};
+
+function createBasePackageMap_PackagesEntry(): PackageMap_PackagesEntry {
+  return { key: "", value: new Uint8Array(0) };
+}
+
+export const PackageMap_PackagesEntry: MessageFns<PackageMap_PackagesEntry> = {
+  encode(message: PackageMap_PackagesEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value.length !== 0) {
+      writer.uint32(18).bytes(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): PackageMap_PackagesEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBasePackageMap_PackagesEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.value = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): PackageMap_PackagesEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? bytesFromBase64(object.value) : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: PackageMap_PackagesEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value.length !== 0) {
+      obj.value = base64FromBytes(message.value);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<PackageMap_PackagesEntry>): PackageMap_PackagesEntry {
+    return PackageMap_PackagesEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<PackageMap_PackagesEntry>): PackageMap_PackagesEntry {
+    const message = createBasePackageMap_PackagesEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+function createBaseSigningCommitment(): SigningCommitment {
+  return { hiding: new Uint8Array(0), binding: new Uint8Array(0) };
+}
+
+export const SigningCommitment: MessageFns<SigningCommitment> = {
+  encode(message: SigningCommitment, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.hiding.length !== 0) {
+      writer.uint32(10).bytes(message.hiding);
+    }
+    if (message.binding.length !== 0) {
+      writer.uint32(18).bytes(message.binding);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SigningCommitment {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSigningCommitment();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.hiding = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.binding = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SigningCommitment {
+    return {
+      hiding: isSet(object.hiding) ? bytesFromBase64(object.hiding) : new Uint8Array(0),
+      binding: isSet(object.binding) ? bytesFromBase64(object.binding) : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: SigningCommitment): unknown {
+    const obj: any = {};
+    if (message.hiding.length !== 0) {
+      obj.hiding = base64FromBytes(message.hiding);
+    }
+    if (message.binding.length !== 0) {
+      obj.binding = base64FromBytes(message.binding);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<SigningCommitment>): SigningCommitment {
+    return SigningCommitment.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<SigningCommitment>): SigningCommitment {
+    const message = createBaseSigningCommitment();
+    message.hiding = object.hiding ?? new Uint8Array(0);
+    message.binding = object.binding ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+function createBaseSigningResult(): SigningResult {
+  return { signatureShare: new Uint8Array(0) };
+}
+
+export const SigningResult: MessageFns<SigningResult> = {
+  encode(message: SigningResult, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.signatureShare.length !== 0) {
+      writer.uint32(10).bytes(message.signatureShare);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SigningResult {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSigningResult();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.signatureShare = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SigningResult {
+    return {
+      signatureShare: isSet(object.signatureShare) ? bytesFromBase64(object.signatureShare) : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: SigningResult): unknown {
+    const obj: any = {};
+    if (message.signatureShare.length !== 0) {
+      obj.signatureShare = base64FromBytes(message.signatureShare);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<SigningResult>): SigningResult {
+    return SigningResult.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<SigningResult>): SigningResult {
+    const message = createBaseSigningResult();
+    message.signatureShare = object.signatureShare ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+function bytesFromBase64(b64: string): Uint8Array {
+  if ((globalThis as any).Buffer) {
+    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+
+function base64FromBytes(arr: Uint8Array): string {
+  if ((globalThis as any).Buffer) {
+    return globalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin: string[] = [];
+    arr.forEach((byte) => {
+      bin.push(globalThis.String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends { $case: string } ? { [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]> } & { $case: T["$case"] }
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+function isObject(value: any): boolean {
+  return typeof value === "object" && value !== null;
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export interface MessageFns<T> {
+  encode(message: T, writer?: BinaryWriter): BinaryWriter;
+  decode(input: BinaryReader | Uint8Array, length?: number): T;
+  fromJSON(object: any): T;
+  toJSON(message: T): unknown;
+  create(base?: DeepPartial<T>): T;
+  fromPartial(object: DeepPartial<T>): T;
+}