@haneullabs/zksend 0.1.0

package/dist/esm/links/claim.d.ts

@@ -0,0 +1,57 @@
+import { HaneulClient } from '@haneullabs/haneul/client';
+import type { HaneulObjectData, HaneulTransactionBlockResponse } from '@haneullabs/haneul/client';
+import type { Keypair } from '@haneullabs/haneul/cryptography';
+import { Transaction } from '@haneullabs/haneul/transactions';
+import type { ZkSendLinkBuilderOptions } from './builder.js';
+import type { LinkAssets } from './utils.js';
+import type { ZkBagContractOptions } from './zk-bag.js';
+export type ZkSendLinkOptions = {
+    claimApi?: string;
+    keypair?: Keypair;
+    client?: HaneulClient;
+    network?: 'mainnet' | 'testnet';
+    host?: string;
+    path?: string;
+    address?: string;
+    isContractLink: boolean;
+    contract?: ZkBagContractOptions | null;
+} & ({
+    address: string;
+    keypair?: never;
+} | {
+    keypair: Keypair;
+    address?: never;
+});
+export declare class ZkSendLink {
+    #private;
+    address: string;
+    keypair?: Keypair;
+    creatorAddress?: string;
+    assets?: LinkAssets;
+    claimed?: boolean;
+    claimedBy?: string;
+    bagObject?: HaneulObjectData | null;
+    constructor({ network, client, keypair, contract, address, host, path, claimApi, isContractLink, }: ZkSendLinkOptions);
+    static fromUrl(url: string, options?: Omit<ZkSendLinkOptions, 'keypair' | 'address' | 'isContractLink'>): Promise<ZkSendLink>;
+    static fromAddress(address: string, options: Omit<ZkSendLinkOptions, 'keypair' | 'address' | 'isContractLink'>): Promise<ZkSendLink>;
+    loadClaimedStatus(): Promise<void>;
+    loadAssets(options?: {
+        transaction?: HaneulTransactionBlockResponse;
+        loadAssets?: boolean;
+        loadClaimedAssets?: boolean;
+    }): Promise<void>;
+    claimAssets(address: string, { reclaim, sign, }?: {
+        reclaim?: false;
+        sign?: never;
+    } | {
+        reclaim: true;
+        sign: (transaction: Uint8Array) => Promise<string>;
+    }): Promise<HaneulTransactionBlockResponse>;
+    createClaimTransaction(address: string, { reclaim, }?: {
+        reclaim?: boolean;
+    }): Transaction;
+    createRegenerateTransaction(sender: string, options?: Omit<ZkSendLinkBuilderOptions, 'sender'>): Promise<{
+        url: string;
+        transaction: Transaction;
+    }>;
+}

package/dist/esm/links/claim.js

@@ -0,0 +1,561 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _client, _contract, _network, _host, _path, _claimApi, _gasCoin, _hasSui, _ownedObjects, _ZkSendLink_instances, loadBagObject_fn, loadBag_fn, loadClaimedAssets_fn, createSponsoredTransaction_fn, executeSponsoredTransaction_fn, fetch_fn, listNonContractClaimableAssets_fn, createNonContractClaimTransaction_fn, loadOwnedObjects_fn;
+import { bcs } from "@haneullabs/haneul/bcs";
+import { getFullnodeUrl, HaneulClient } from "@haneullabs/haneul/client";
+import { Ed25519Keypair } from "@haneullabs/haneul/keypairs/ed25519";
+import { Transaction } from "@haneullabs/haneul/transactions";
+import {
+  fromBase64,
+  normalizeStructTag,
+  normalizeHaneulAddress,
+  normalizeHaneulObjectId,
+  parseStructTag,
+  HANEUL_TYPE_ARG,
+  toBase64
+} from "@haneullabs/haneul/utils";
+import { ZkSendLinkBuilder } from "./builder.js";
+import { getAssetsFromTransaction, isOwner, ownedAfterChange } from "./utils.js";
+import { getContractIds, ZkBag } from "./zk-bag.js";
+const DEFAULT_ZK_SEND_LINK_OPTIONS = {
+  host: "https://api.slush.app",
+  path: "/claim",
+  network: "mainnet"
+};
+const HANEUL_COIN_TYPE = normalizeStructTag(HANEUL_TYPE_ARG);
+const HANEUL_COIN_OBJECT_TYPE = normalizeStructTag("0x2::coin::Coin<0x2::haneul::HANEUL>");
+const _ZkSendLink = class _ZkSendLink {
+  constructor({
+    network = DEFAULT_ZK_SEND_LINK_OPTIONS.network,
+    client = new HaneulClient({ url: getFullnodeUrl(network) }),
+    keypair,
+    contract = getContractIds(network),
+    address,
+    host = DEFAULT_ZK_SEND_LINK_OPTIONS.host,
+    path = DEFAULT_ZK_SEND_LINK_OPTIONS.path,
+    claimApi = `${host}/api`,
+    isContractLink
+  }) {
+    __privateAdd(this, _ZkSendLink_instances);
+    __privateAdd(this, _client);
+    __privateAdd(this, _contract);
+    __privateAdd(this, _network);
+    __privateAdd(this, _host);
+    __privateAdd(this, _path);
+    __privateAdd(this, _claimApi);
+    // State for non-contract based links
+    __privateAdd(this, _gasCoin);
+    __privateAdd(this, _hasSui, false);
+    __privateAdd(this, _ownedObjects, []);
+    if (!keypair && !address) {
+      throw new Error("Either keypair or address must be provided");
+    }
+    __privateSet(this, _client, client);
+    this.keypair = keypair;
+    this.address = address ?? keypair.toHaneulAddress();
+    __privateSet(this, _claimApi, claimApi);
+    __privateSet(this, _network, network);
+    __privateSet(this, _host, host);
+    __privateSet(this, _path, path);
+    if (isContractLink) {
+      if (!contract) {
+        throw new Error("Contract options are required for contract based links");
+      }
+      __privateSet(this, _contract, new ZkBag(contract.packageId, contract));
+    }
+  }
+  static async fromUrl(url, options = {}) {
+    const parsed = new URL(url);
+    const isContractLink = parsed.hash.startsWith("#$");
+    const parsedNetwork = parsed.searchParams.get("network") === "testnet" ? "testnet" : "mainnet";
+    const network = options.network ?? parsedNetwork;
+    let link;
+    if (isContractLink) {
+      const keypair = Ed25519Keypair.fromSecretKey(fromBase64(parsed.hash.slice(2)));
+      link = new _ZkSendLink({
+        ...options,
+        keypair,
+        network,
+        host: `${parsed.protocol}//${parsed.host}`,
+        path: parsed.pathname,
+        isContractLink: true
+      });
+    } else {
+      const keypair = Ed25519Keypair.fromSecretKey(
+        fromBase64(isContractLink ? parsed.hash.slice(2) : parsed.hash.slice(1))
+      );
+      link = new _ZkSendLink({
+        ...options,
+        keypair,
+        network,
+        host: `${parsed.protocol}//${parsed.host}`,
+        path: parsed.pathname,
+        isContractLink: false
+      });
+    }
+    await link.loadAssets();
+    return link;
+  }
+  static async fromAddress(address, options) {
+    const link = new _ZkSendLink({
+      ...options,
+      address,
+      isContractLink: true
+    });
+    await link.loadAssets();
+    return link;
+  }
+  async loadClaimedStatus() {
+    await __privateMethod(this, _ZkSendLink_instances, loadBag_fn).call(this, { loadAssets: false });
+  }
+  async loadAssets(options = {}) {
+    if (__privateGet(this, _contract)) {
+      await __privateMethod(this, _ZkSendLink_instances, loadBag_fn).call(this, options);
+    } else {
+      await __privateMethod(this, _ZkSendLink_instances, loadOwnedObjects_fn).call(this, options);
+    }
+  }
+  async claimAssets(address, {
+    reclaim,
+    sign
+  } = {}) {
+    if (!this.keypair && !sign) {
+      throw new Error("Cannot claim assets without links keypair");
+    }
+    if (this.claimed) {
+      throw new Error("Assets have already been claimed");
+    }
+    if (!this.assets) {
+      throw new Error(
+        "Link assets could not be loaded.  Link has not been indexed or has already been claimed"
+      );
+    }
+    if (!__privateGet(this, _contract)) {
+      const bytes2 = await this.createClaimTransaction(address).build({
+        client: __privateGet(this, _client)
+      });
+      const signature2 = sign ? await sign(bytes2) : (await this.keypair.signTransaction(bytes2)).signature;
+      return __privateGet(this, _client).executeTransactionBlock({
+        transactionBlock: bytes2,
+        signature: signature2
+      });
+    }
+    if (!this.assets) {
+      await __privateMethod(this, _ZkSendLink_instances, loadBag_fn).call(this);
+    }
+    const tx = this.createClaimTransaction(address, { reclaim });
+    const sponsored = await __privateMethod(this, _ZkSendLink_instances, createSponsoredTransaction_fn).call(this, tx, address, reclaim ? address : this.keypair.toHaneulAddress());
+    const bytes = fromBase64(sponsored.bytes);
+    const signature = sign ? await sign(bytes) : (await this.keypair.signTransaction(bytes)).signature;
+    const { digest } = await __privateMethod(this, _ZkSendLink_instances, executeSponsoredTransaction_fn).call(this, sponsored, signature);
+    const result = await __privateGet(this, _client).waitForTransaction({
+      digest,
+      options: { showEffects: true }
+    });
+    if (result.effects?.status.status !== "success") {
+      throw new Error(
+        `Claim transaction failed: ${result.effects?.status.error ?? "Unknown error"}`
+      );
+    }
+    return result;
+  }
+  createClaimTransaction(address, {
+    reclaim
+  } = {}) {
+    if (!__privateGet(this, _contract)) {
+      return __privateMethod(this, _ZkSendLink_instances, createNonContractClaimTransaction_fn).call(this, address);
+    }
+    if (!this.keypair && !reclaim) {
+      throw new Error("Cannot claim assets without the links keypair");
+    }
+    const tx = new Transaction();
+    const sender = reclaim ? address : this.keypair.toHaneulAddress();
+    tx.setSender(sender);
+    const store = tx.object(__privateGet(this, _contract).ids.bagStoreId);
+    const command = reclaim ? __privateGet(this, _contract).reclaim({ arguments: [store, this.address] }) : __privateGet(this, _contract).init_claim({ arguments: [store] });
+    const [bag, proof] = tx.add(command);
+    const objectsToTransfer = [];
+    const objects = [...this.assets?.coins ?? [], ...this.assets?.nfts ?? []];
+    for (const object of objects) {
+      objectsToTransfer.push(
+        __privateGet(this, _contract).claim({
+          arguments: [
+            bag,
+            proof,
+            tx.receivingRef({
+              objectId: object.objectId,
+              version: object.version,
+              digest: object.digest
+            })
+          ],
+          typeArguments: [object.type]
+        })
+      );
+    }
+    if (objectsToTransfer.length > 0) {
+      tx.transferObjects(objectsToTransfer, address);
+    }
+    tx.add(__privateGet(this, _contract).finalize({ arguments: [bag, proof] }));
+    return tx;
+  }
+  async createRegenerateTransaction(sender, options = {}) {
+    if (!this.assets) {
+      await __privateMethod(this, _ZkSendLink_instances, loadBag_fn).call(this);
+    }
+    if (this.claimed) {
+      throw new Error("Assets have already been claimed");
+    }
+    if (!__privateGet(this, _contract)) {
+      throw new Error("Regenerating non-contract based links is not supported");
+    }
+    const tx = new Transaction();
+    tx.setSender(sender);
+    const store = tx.object(__privateGet(this, _contract).ids.bagStoreId);
+    const newLinkKp = Ed25519Keypair.generate();
+    const newLink = new ZkSendLinkBuilder({
+      ...options,
+      sender,
+      client: __privateGet(this, _client),
+      contract: __privateGet(this, _contract).ids,
+      host: __privateGet(this, _host),
+      path: __privateGet(this, _path),
+      keypair: newLinkKp
+    });
+    const to = tx.pure.address(newLinkKp.toHaneulAddress());
+    tx.add(__privateGet(this, _contract).update_receiver({ arguments: [store, this.address, to] }));
+    return {
+      url: newLink.getLink(),
+      transaction: tx
+    };
+  }
+};
+_client = new WeakMap();
+_contract = new WeakMap();
+_network = new WeakMap();
+_host = new WeakMap();
+_path = new WeakMap();
+_claimApi = new WeakMap();
+_gasCoin = new WeakMap();
+_hasSui = new WeakMap();
+_ownedObjects = new WeakMap();
+_ZkSendLink_instances = new WeakSet();
+loadBagObject_fn = async function() {
+  if (!__privateGet(this, _contract)) {
+    throw new Error("Cannot load bag object for non-contract based links");
+  }
+  const bagField = await __privateGet(this, _client).getDynamicFieldObject({
+    parentId: __privateGet(this, _contract).ids.bagStoreTableId,
+    name: {
+      type: "address",
+      value: this.address
+    }
+  });
+  this.bagObject = bagField.data;
+  if (this.bagObject) {
+    this.claimed = false;
+  }
+};
+loadBag_fn = async function({
+  transaction,
+  loadAssets = true,
+  loadClaimedAssets = loadAssets
+} = {}) {
+  if (!__privateGet(this, _contract)) {
+    return;
+  }
+  if (!this.bagObject || !this.claimed) {
+    await __privateMethod(this, _ZkSendLink_instances, loadBagObject_fn).call(this);
+  }
+  if (!loadAssets) {
+    return;
+  }
+  if (!this.bagObject) {
+    if (loadClaimedAssets) {
+      await __privateMethod(this, _ZkSendLink_instances, loadClaimedAssets_fn).call(this);
+    }
+    return;
+  }
+  const bagId = this.bagObject.content.fields.value.fields?.id?.id;
+  if (bagId && transaction?.balanceChanges && transaction.objectChanges) {
+    this.assets = getAssetsFromTransaction({
+      transaction,
+      address: bagId,
+      isSent: false
+    });
+    return;
+  }
+  const itemIds = this.bagObject?.content?.fields?.value?.fields?.item_ids.fields.contents;
+  this.creatorAddress = this.bagObject?.content?.fields?.value?.fields?.owner;
+  if (!itemIds) {
+    throw new Error("Invalid bag field");
+  }
+  const objectsResponse = await __privateGet(this, _client).multiGetObjects({
+    ids: itemIds,
+    options: {
+      showType: true,
+      showContent: true
+    }
+  });
+  this.assets = {
+    balances: [],
+    nfts: [],
+    coins: []
+  };
+  const balances = /* @__PURE__ */ new Map();
+  objectsResponse.forEach((object, i) => {
+    if (!object.data || !object.data.type) {
+      throw new Error(`Failed to load claimable object ${itemIds[i]}`);
+    }
+    const type = parseStructTag(normalizeStructTag(object.data.type));
+    if (type.address === normalizeHaneulAddress("0x2") && type.module === "coin" && type.name === "Coin") {
+      this.assets.coins.push({
+        objectId: object.data.objectId,
+        type: object.data.type,
+        version: object.data.version,
+        digest: object.data.digest
+      });
+      if (object.data.content?.dataType === "moveObject") {
+        const amount = BigInt(object.data.content.fields.balance);
+        const coinType = normalizeStructTag(
+          parseStructTag(object.data.content.type).typeParams[0]
+        );
+        if (!balances.has(coinType)) {
+          balances.set(coinType, { coinType, amount });
+        } else {
+          balances.get(coinType).amount += amount;
+        }
+      }
+    } else {
+      this.assets.nfts.push({
+        objectId: object.data.objectId,
+        type: object.data.type,
+        version: object.data.version,
+        digest: object.data.digest
+      });
+    }
+  });
+  this.assets.balances = [...balances.values()];
+};
+loadClaimedAssets_fn = async function() {
+  const result = await __privateGet(this, _client).queryTransactionBlocks({
+    limit: 1,
+    filter: {
+      FromAddress: this.address
+    },
+    options: {
+      showObjectChanges: true,
+      showBalanceChanges: true,
+      showInput: true
+    }
+  });
+  if (!result?.data[0]) {
+    return;
+  }
+  const [tx] = result.data;
+  if (tx.transaction?.data.transaction.kind !== "ProgrammableTransaction") {
+    return;
+  }
+  const transfer = tx.transaction.data.transaction.transactions.findLast(
+    (tx2) => "TransferObjects" in tx2
+  );
+  if (!transfer) {
+    return;
+  }
+  const receiverArg = transfer.TransferObjects[1];
+  if (!(typeof receiverArg === "object" && "Input" in receiverArg)) {
+    return;
+  }
+  const input = tx.transaction.data.transaction.inputs[receiverArg.Input];
+  if (input.type !== "pure") {
+    return;
+  }
+  const receiver = typeof input.value === "string" ? input.value : bcs.Address.parse(new Uint8Array(input.value.Pure));
+  this.claimed = true;
+  this.claimedBy = receiver;
+  this.assets = getAssetsFromTransaction({
+    transaction: tx,
+    address: receiver,
+    isSent: false
+  });
+};
+createSponsoredTransaction_fn = async function(tx, claimer, sender) {
+  return __privateMethod(this, _ZkSendLink_instances, fetch_fn).call(this, "transaction-blocks/sponsor", {
+    method: "POST",
+    body: JSON.stringify({
+      network: __privateGet(this, _network),
+      sender,
+      claimer,
+      transactionBlockKindBytes: toBase64(
+        await tx.build({
+          onlyTransactionKind: true,
+          client: __privateGet(this, _client)
+        })
+      )
+    })
+  });
+};
+executeSponsoredTransaction_fn = async function(input, signature) {
+  return __privateMethod(this, _ZkSendLink_instances, fetch_fn).call(this, `transaction-blocks/sponsor/${input.digest}`, {
+    method: "POST",
+    body: JSON.stringify({
+      signature
+    })
+  });
+};
+fetch_fn = async function(path, init) {
+  const res = await fetch(`${__privateGet(this, _claimApi)}/v1/${path}`, {
+    ...init,
+    headers: {
+      ...init.headers,
+      "Content-Type": "application/json"
+    }
+  });
+  if (!res.ok) {
+    console.error(`${__privateGet(this, _claimApi)}/v1/${path}`, await res.text());
+    throw new Error(`Request to claim API failed with status code ${res.status}`);
+  }
+  const { data } = await res.json();
+  return data;
+};
+listNonContractClaimableAssets_fn = async function() {
+  const balances = [];
+  const nfts = [];
+  const coins = [];
+  if (__privateGet(this, _ownedObjects).length === 0 && !__privateGet(this, _hasSui)) {
+    return {
+      balances,
+      nfts,
+      coins
+    };
+  }
+  const address = new Ed25519Keypair().toHaneulAddress();
+  const normalizedAddress = normalizeHaneulAddress(address);
+  const tx = this.createClaimTransaction(normalizedAddress);
+  if (__privateGet(this, _gasCoin) || !__privateGet(this, _hasSui)) {
+    tx.setGasPayment([]);
+  }
+  const dryRun = await __privateGet(this, _client).dryRunTransactionBlock({
+    transactionBlock: await tx.build({ client: __privateGet(this, _client) })
+  });
+  dryRun.balanceChanges.forEach((balanceChange) => {
+    if (BigInt(balanceChange.amount) > 0n && isOwner(balanceChange.owner, normalizedAddress)) {
+      balances.push({
+        coinType: normalizeStructTag(balanceChange.coinType),
+        amount: BigInt(balanceChange.amount)
+      });
+    }
+  });
+  dryRun.objectChanges.forEach((objectChange) => {
+    if ("objectType" in objectChange) {
+      const type = parseStructTag(objectChange.objectType);
+      if (type.address === normalizeHaneulAddress("0x2") && type.module === "coin" && type.name === "Coin") {
+        if (ownedAfterChange(objectChange, normalizedAddress)) {
+          coins.push(objectChange);
+        }
+        return;
+      }
+    }
+    if (ownedAfterChange(objectChange, normalizedAddress)) {
+      nfts.push(objectChange);
+    }
+  });
+  return {
+    balances,
+    nfts,
+    coins
+  };
+};
+createNonContractClaimTransaction_fn = function(address) {
+  if (!this.keypair) {
+    throw new Error("Cannot claim assets without the links keypair");
+  }
+  const tx = new Transaction();
+  tx.setSender(this.keypair.toHaneulAddress());
+  const objectsToTransfer = __privateGet(this, _ownedObjects).filter((object) => {
+    if (__privateGet(this, _gasCoin)) {
+      if (object.objectId === __privateGet(this, _gasCoin).coinObjectId) {
+        return false;
+      }
+    } else if (object.type === HANEUL_COIN_OBJECT_TYPE) {
+      return false;
+    }
+    return true;
+  }).map((object) => tx.object(object.objectId));
+  if (__privateGet(this, _gasCoin) && this.creatorAddress) {
+    tx.transferObjects([tx.gas], this.creatorAddress);
+  } else {
+    objectsToTransfer.push(tx.gas);
+  }
+  if (objectsToTransfer.length > 0) {
+    tx.transferObjects(objectsToTransfer, address);
+  }
+  return tx;
+};
+loadOwnedObjects_fn = async function({
+  loadClaimedAssets = true
+} = {}) {
+  this.assets = {
+    nfts: [],
+    balances: [],
+    coins: []
+  };
+  let nextCursor;
+  do {
+    const ownedObjects = await __privateGet(this, _client).getOwnedObjects({
+      cursor: nextCursor,
+      owner: this.address,
+      options: {
+        showType: true,
+        showContent: true
+      }
+    });
+    nextCursor = ownedObjects.hasNextPage ? ownedObjects.nextCursor : null;
+    for (const object of ownedObjects.data) {
+      if (object.data) {
+        __privateGet(this, _ownedObjects).push({
+          objectId: normalizeHaneulObjectId(object.data.objectId),
+          version: object.data.version,
+          digest: object.data.digest,
+          type: normalizeStructTag(object.data.type)
+        });
+      }
+    }
+  } while (nextCursor);
+  const coins = await __privateGet(this, _client).getCoins({
+    coinType: HANEUL_COIN_TYPE,
+    owner: this.address
+  });
+  __privateSet(this, _hasSui, coins.data.length > 0);
+  __privateSet(this, _gasCoin, coins.data.find((coin) => BigInt(coin.balance) % 1000n === 987n));
+  const result = await __privateGet(this, _client).queryTransactionBlocks({
+    limit: 1,
+    order: "ascending",
+    filter: {
+      ToAddress: this.address
+    },
+    options: {
+      showInput: true,
+      showBalanceChanges: true,
+      showObjectChanges: true
+    }
+  });
+  this.creatorAddress = result.data[0]?.transaction?.data.sender;
+  if (__privateGet(this, _hasSui) || __privateGet(this, _ownedObjects).length > 0) {
+    this.claimed = false;
+    this.assets = await __privateMethod(this, _ZkSendLink_instances, listNonContractClaimableAssets_fn).call(this);
+  } else if (result.data[0] && loadClaimedAssets) {
+    this.claimed = true;
+    await __privateMethod(this, _ZkSendLink_instances, loadClaimedAssets_fn).call(this);
+  }
+};
+let ZkSendLink = _ZkSendLink;
+export {
+  ZkSendLink
+};
+//# sourceMappingURL=claim.js.map