@fepvenancio/stela-sdk 0.2.3 → 0.4.0

package/dist/index.cjs

@@ -24,7 +24,7 @@ var STATUS_LABELS = {
 
 // src/constants/addresses.ts
 var STELA_ADDRESS = {
-  sepolia: "0x006885f85de0e79efc7826e2ca19ef8a13e5e4516897ad52dc505723f8ce6b90",
+  sepolia: "0x00b7deedb4ab03d94f54da2e7c911c2336b19c2a4610eb98f55cd7be5a53ece0",
   mainnet: "0x0"
 };
 var VALID_NETWORKS = ["sepolia", "mainnet"];
@@ -283,7 +283,11 @@ var SELECTORS = {
   InscriptionRepaid: starknet.hash.getSelectorFromName("InscriptionRepaid"),
   InscriptionLiquidated: starknet.hash.getSelectorFromName("InscriptionLiquidated"),
   SharesRedeemed: starknet.hash.getSelectorFromName("SharesRedeemed"),
-  TransferSingle: starknet.hash.getSelectorFromName("TransferSingle")
+  TransferSingle: starknet.hash.getSelectorFromName("TransferSingle"),
+  OrderSettled: starknet.hash.getSelectorFromName("OrderSettled"),
+  OrderFilled: starknet.hash.getSelectorFromName("OrderFilled"),
+  OrderCancelled: starknet.hash.getSelectorFromName("OrderCancelled"),
+  OrdersBulkCancelled: starknet.hash.getSelectorFromName("OrdersBulkCancelled")
 };
 function feltsToU256(low, high) {
   return starknet.uint256.uint256ToBN({ low: BigInt(low), high: BigInt(high) });
@@ -362,6 +366,48 @@ function parseEvent(raw) {
         block_number: raw.block_number
       };
     }
+    case SELECTORS.OrderSettled: {
+      return {
+        type: "OrderSettled",
+        inscription_id: feltsToU256(raw.keys[1], raw.keys[2]),
+        borrower: raw.keys[3],
+        lender: raw.keys[4],
+        relayer: raw.data[0],
+        relayer_fee_amount: feltsToU256(raw.data[1], raw.data[2]),
+        transaction_hash: raw.transaction_hash,
+        block_number: raw.block_number
+      };
+    }
+    case SELECTORS.OrderFilled: {
+      return {
+        type: "OrderFilled",
+        inscription_id: feltsToU256(raw.keys[1], raw.keys[2]),
+        order_hash: raw.keys[3],
+        taker: raw.keys[4],
+        fill_bps: feltsToU256(raw.data[0], raw.data[1]),
+        total_filled_bps: feltsToU256(raw.data[2], raw.data[3]),
+        transaction_hash: raw.transaction_hash,
+        block_number: raw.block_number
+      };
+    }
+    case SELECTORS.OrderCancelled: {
+      return {
+        type: "OrderCancelled",
+        order_hash: raw.keys[1],
+        maker: raw.data[0],
+        transaction_hash: raw.transaction_hash,
+        block_number: raw.block_number
+      };
+    }
+    case SELECTORS.OrdersBulkCancelled: {
+      return {
+        type: "OrdersBulkCancelled",
+        maker: raw.keys[1],
+        new_min_nonce: raw.data[0],
+        transaction_hash: raw.transaction_hash,
+        block_number: raw.block_number
+      };
+    }
     default:
       return null;
   }
@@ -438,6 +484,16 @@ function getInscriptionOrderTypedData(params) {
     }
   };
 }
+function getPrivateLendOfferTypedData(params) {
+  return getLendOfferTypedData({
+    orderHash: params.orderHash,
+    lender: "0x0",
+    issuedDebtPercentage: params.issuedDebtPercentage,
+    nonce: params.nonce,
+    chainId: params.chainId,
+    lenderCommitment: params.depositCommitment
+  });
+}
 function getLendOfferTypedData(params) {
   return {
     types: {
@@ -451,7 +507,8 @@ function getLendOfferTypedData(params) {
         { name: "order_hash", type: "felt" },
         { name: "lender", type: "ContractAddress" },
         { name: "issued_debt_percentage", type: "u256" },
-        { name: "nonce", type: "felt" }
+        { name: "nonce", type: "felt" },
+        { name: "lender_commitment", type: "felt" }
       ],
       u256: [
         { name: "low", type: "u128" },
@@ -470,7 +527,8 @@ function getLendOfferTypedData(params) {
         low: (params.issuedDebtPercentage & (1n << 128n) - 1n).toString(),
         high: (params.issuedDebtPercentage >> 128n).toString()
       },
-      nonce: params.nonce.toString()
+      nonce: params.nonce.toString(),
+      lender_commitment: params.lenderCommitment ?? "0"
     }
   };
 }
@@ -482,6 +540,54 @@ function serializeSignature(sig) {
 function deserializeSignature(stored) {
   return [stored.r, stored.s];
 }
+var COMMITMENT_DOMAIN = starknet.shortString.encodeShortString("STELA_COMMITMENT_V1");
+var NULLIFIER_DOMAIN = starknet.shortString.encodeShortString("STELA_NULLIFIER_V1");
+function computeCommitment(owner, inscriptionId, shares, salt) {
+  const [idLow, idHigh] = toU256(inscriptionId);
+  const [sharesLow, sharesHigh] = toU256(shares);
+  return starknet.hash.computePoseidonHashOnElements([
+    COMMITMENT_DOMAIN,
+    owner,
+    idLow,
+    idHigh,
+    sharesLow,
+    sharesHigh,
+    salt
+  ]);
+}
+function computeNullifier(commitment, ownerSecret) {
+  return starknet.hash.computePoseidonHashOnElements([NULLIFIER_DOMAIN, commitment, ownerSecret]);
+}
+function hashPair(left, right) {
+  return starknet.hash.computePoseidonHashOnElements([left, right]);
+}
+function generateSalt() {
+  const bytes = new Uint8Array(31);
+  crypto.getRandomValues(bytes);
+  return "0x" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function computeDepositCommitment(depositor, token, amount, salt) {
+  const [amountLow, amountHigh] = toU256(amount);
+  return starknet.hash.computePoseidonHashOnElements([
+    COMMITMENT_DOMAIN,
+    depositor,
+    token,
+    amountLow,
+    amountHigh,
+    "0x" + salt.toString(16)
+  ]);
+}
+function createPrivateNote(owner, inscriptionId, shares, salt) {
+  const noteSalt = salt ?? generateSalt();
+  const commitment = computeCommitment(owner, inscriptionId, shares, noteSalt);
+  return {
+    owner,
+    inscriptionId,
+    shares,
+    salt: noteSalt,
+    commitment
+  };
+}
 
 // src/abi/stela.json
 var stela_default = [
@@ -596,6 +702,46 @@ var stela_default = [
       }
     ]
   },
+  {
+    type: "struct",
+    name: "stela::types::private_redeem::PrivateRedeemRequest",
+    members: [
+      {
+        name: "root",
+        type: "core::felt252"
+      },
+      {
+        name: "inscription_id",
+        type: "core::integer::u256"
+      },
+      {
+        name: "shares",
+        type: "core::integer::u256"
+      },
+      {
+        name: "nullifier",
+        type: "core::felt252"
+      },
+      {
+        name: "change_commitment",
+        type: "core::felt252"
+      },
+      {
+        name: "recipient",
+        type: "core::starknet::contract_address::ContractAddress"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "core::array::Span::<core::felt252>",
+    members: [
+      {
+        name: "snapshot",
+        type: "@core::array::Array::<core::felt252>"
+      }
+    ]
+  },
   {
     type: "struct",
     name: "stela::snip12::InscriptionOrder",
@@ -665,6 +811,44 @@ var stela_default = [
       {
         name: "nonce",
         type: "core::felt252"
+      },
+      {
+        name: "lender_commitment",
+        type: "core::felt252"
+      }
+    ]
+  },
+  {
+    type: "struct",
+    name: "stela::types::signed_order::SignedOrder",
+    members: [
+      {
+        name: "maker",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "allowed_taker",
+        type: "core::starknet::contract_address::ContractAddress"
+      },
+      {
+        name: "inscription_id",
+        type: "core::integer::u256"
+      },
+      {
+        name: "bps",
+        type: "core::integer::u256"
+      },
+      {
+        name: "deadline",
+        type: "core::integer::u64"
+      },
+      {
+        name: "nonce",
+        type: "core::felt252"
+      },
+      {
+        name: "min_fill_bps",
+        type: "core::integer::u256"
       }
     ]
   },
@@ -810,6 +994,22 @@ var stela_default = [
         outputs: [],
         state_mutability: "external"
       },
+      {
+        type: "function",
+        name: "private_redeem",
+        inputs: [
+          {
+            name: "request",
+            type: "stela::types::private_redeem::PrivateRedeemRequest"
+          },
+          {
+            name: "proof",
+            type: "core::array::Span::<core::felt252>"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
       {
         type: "function",
         name: "settle",
@@ -846,6 +1046,50 @@ var stela_default = [
         outputs: [],
         state_mutability: "external"
       },
+      {
+        type: "function",
+        name: "fill_signed_order",
+        inputs: [
+          {
+            name: "order",
+            type: "stela::types::signed_order::SignedOrder"
+          },
+          {
+            name: "signature",
+            type: "core::array::Array::<core::felt252>"
+          },
+          {
+            name: "fill_bps",
+            type: "core::integer::u256"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "cancel_order",
+        inputs: [
+          {
+            name: "order",
+            type: "stela::types::signed_order::SignedOrder"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
+      {
+        type: "function",
+        name: "cancel_orders_by_nonce",
+        inputs: [
+          {
+            name: "min_nonce",
+            type: "core::felt252"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
       {
         type: "function",
         name: "get_inscription",
@@ -958,6 +1202,81 @@ var stela_default = [
         ],
         state_mutability: "view"
       },
+      {
+        type: "function",
+        name: "is_order_registered",
+        inputs: [
+          {
+            name: "order_hash",
+            type: "core::felt252"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::bool"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "is_order_cancelled",
+        inputs: [
+          {
+            name: "order_hash",
+            type: "core::felt252"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::bool"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "get_filled_bps",
+        inputs: [
+          {
+            name: "order_hash",
+            type: "core::felt252"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::integer::u256"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "get_maker_min_nonce",
+        inputs: [
+          {
+            name: "maker",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [
+          {
+            type: "core::felt252"
+          }
+        ],
+        state_mutability: "view"
+      },
+      {
+        type: "function",
+        name: "get_privacy_pool",
+        inputs: [],
+        outputs: [
+          {
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        state_mutability: "view"
+      },
       {
         type: "function",
         name: "set_inscription_fee",
@@ -1030,6 +1349,18 @@ var stela_default = [
         outputs: [],
         state_mutability: "external"
       },
+      {
+        type: "function",
+        name: "set_privacy_pool",
+        inputs: [
+          {
+            name: "privacy_pool",
+            type: "core::starknet::contract_address::ContractAddress"
+          }
+        ],
+        outputs: [],
+        state_mutability: "external"
+      },
       {
         type: "function",
         name: "pause",
@@ -1091,16 +1422,6 @@ var stela_default = [
       }
     ]
   },
-  {
-    type: "struct",
-    name: "core::array::Span::<core::felt252>",
-    members: [
-      {
-        name: "snapshot",
-        type: "@core::array::Array::<core::felt252>"
-      }
-    ]
-  },
   {
     type: "struct",
     name: "core::byte_array::ByteArray",
@@ -1902,6 +2223,121 @@ var stela_default = [
       }
     ]
   },
+  {
+    type: "event",
+    name: "stela::stela::StelaProtocol::OrderFilled",
+    kind: "struct",
+    members: [
+      {
+        name: "inscription_id",
+        type: "core::integer::u256",
+        kind: "key"
+      },
+      {
+        name: "order_hash",
+        type: "core::felt252",
+        kind: "key"
+      },
+      {
+        name: "taker",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "fill_bps",
+        type: "core::integer::u256",
+        kind: "data"
+      },
+      {
+        name: "total_filled_bps",
+        type: "core::integer::u256",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "stela::stela::StelaProtocol::OrderCancelled",
+    kind: "struct",
+    members: [
+      {
+        name: "order_hash",
+        type: "core::felt252",
+        kind: "key"
+      },
+      {
+        name: "maker",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "stela::stela::StelaProtocol::OrdersBulkCancelled",
+    kind: "struct",
+    members: [
+      {
+        name: "maker",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "key"
+      },
+      {
+        name: "new_min_nonce",
+        type: "core::felt252",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "stela::stela::StelaProtocol::PrivateSettled",
+    kind: "struct",
+    members: [
+      {
+        name: "inscription_id",
+        type: "core::integer::u256",
+        kind: "key"
+      },
+      {
+        name: "lender_commitment",
+        type: "core::felt252",
+        kind: "key"
+      },
+      {
+        name: "shares_committed",
+        type: "core::integer::u256",
+        kind: "data"
+      }
+    ]
+  },
+  {
+    type: "event",
+    name: "stela::stela::StelaProtocol::PrivateSharesRedeemed",
+    kind: "struct",
+    members: [
+      {
+        name: "inscription_id",
+        type: "core::integer::u256",
+        kind: "key"
+      },
+      {
+        name: "nullifier",
+        type: "core::felt252",
+        kind: "key"
+      },
+      {
+        name: "shares",
+        type: "core::integer::u256",
+        kind: "data"
+      },
+      {
+        name: "recipient",
+        type: "core::starknet::contract_address::ContractAddress",
+        kind: "data"
+      }
+    ]
+  },
   {
     type: "event",
     name: "stela::stela::StelaProtocol::Event",
@@ -1971,6 +2407,31 @@ var stela_default = [
         name: "OrderSettled",
         type: "stela::stela::StelaProtocol::OrderSettled",
         kind: "nested"
+      },
+      {
+        name: "OrderFilled",
+        type: "stela::stela::StelaProtocol::OrderFilled",
+        kind: "nested"
+      },
+      {
+        name: "OrderCancelled",
+        type: "stela::stela::StelaProtocol::OrderCancelled",
+        kind: "nested"
+      },
+      {
+        name: "OrdersBulkCancelled",
+        type: "stela::stela::StelaProtocol::OrdersBulkCancelled",
+        kind: "nested"
+      },
+      {
+        name: "PrivateSettled",
+        type: "stela::stela::StelaProtocol::PrivateSettled",
+        kind: "nested"
+      },
+      {
+        name: "PrivateSharesRedeemed",
+        type: "stela::stela::StelaProtocol::PrivateSharesRedeemed",
+        kind: "nested"
       }
     ]
   }
@@ -2007,13 +2468,37 @@ var InscriptionClient = class {
     return extractU256(result);
   }
   async getNonce(address) {
-    const result = await this.contract.call("nonces", [address]);
+    const result = await this.contract.call("nonces", [address], { blockIdentifier: "latest" });
     return BigInt(String(result[0] ?? "0"));
   }
   async getRelayerFee() {
     const result = await this.contract.call("get_relayer_fee");
     return extractU256(result);
   }
+  async getTreasury() {
+    const result = await this.contract.call("get_treasury");
+    return String(result[0]);
+  }
+  async isPaused() {
+    const result = await this.contract.call("is_paused");
+    return Boolean(result[0]);
+  }
+  async isOrderRegistered(orderHash) {
+    const result = await this.contract.call("is_order_registered", [orderHash]);
+    return Boolean(result[0]);
+  }
+  async isOrderCancelled(orderHash) {
+    const result = await this.contract.call("is_order_cancelled", [orderHash]);
+    return Boolean(result[0]);
+  }
+  async getFilledBps(orderHash) {
+    const result = await this.contract.call("get_filled_bps", [orderHash]);
+    return extractU256(result);
+  }
+  async getMakerMinNonce(maker) {
+    const result = await this.contract.call("get_maker_min_nonce", [maker], { blockIdentifier: "latest" });
+    return String(result[0] ?? "0");
+  }
   // ── Call Builders ──────────────────────────────────────────────────
   buildCreateInscription(params) {
     const calldata = [
@@ -2062,6 +2547,53 @@ var InscriptionClient = class {
       calldata: [...toU256(inscriptionId), ...toU256(shares)]
     };
   }
+  buildPrivateRedeem(request, proof) {
+    const calldata = [
+      // PrivateRedeemRequest struct fields (must match Cairo Serde order)
+      request.root,
+      ...toU256(request.inscriptionId),
+      ...toU256(request.shares),
+      request.nullifier,
+      request.changeCommitment,
+      request.recipient,
+      // proof array
+      String(proof.length),
+      ...proof
+    ];
+    return { contractAddress: this.address, entrypoint: "private_redeem", calldata };
+  }
+  /**
+   * Build a shield() call on the privacy pool contract.
+   * The depositor shields tokens into the pool, creating a commitment that can
+   * later be consumed during private settlement.
+   */
+  buildShieldDeposit(params) {
+    return {
+      contractAddress: params.privacyPoolAddress,
+      entrypoint: "shield",
+      calldata: [
+        params.token,
+        ...toU256(params.amount),
+        params.commitment
+      ]
+    };
+  }
+  /**
+   * Build a settle() call for private settlement.
+   *
+   * In a private settlement, the lender is zero address and the lender_commitment
+   * is the deposit commitment from the privacy pool. The contract skips lender
+   * signature verification and instead consumes the deposit from the privacy pool.
+   */
+  buildSettlePrivate(params) {
+    return this.buildSettle({
+      ...params,
+      offer: {
+        ...params.offer,
+        lender: "0x0"
+      }
+    });
+  }
   buildSettle(params) {
     const calldata = [
       // Order struct fields
@@ -2090,12 +2622,50 @@ var InscriptionClient = class {
       params.offer.lender,
       ...toU256(params.offer.issuedDebtPercentage),
       params.offer.nonce.toString(),
+      params.offer.lenderCommitment ?? "0",
       // lender_sig array
       String(params.lenderSig.length),
       ...params.lenderSig
     ];
     return { contractAddress: this.address, entrypoint: "settle", calldata };
   }
+  buildFillSignedOrder(order, signature, fillBps) {
+    const calldata = [
+      // SignedOrder struct fields
+      order.maker,
+      order.allowed_taker,
+      ...toU256(order.inscription_id),
+      ...toU256(order.bps),
+      order.deadline.toString(),
+      order.nonce,
+      ...toU256(order.min_fill_bps),
+      // signature array
+      String(signature.length),
+      ...signature,
+      // fill_bps
+      ...toU256(fillBps)
+    ];
+    return { contractAddress: this.address, entrypoint: "fill_signed_order", calldata };
+  }
+  buildCancelOrder(order) {
+    const calldata = [
+      order.maker,
+      order.allowed_taker,
+      ...toU256(order.inscription_id),
+      ...toU256(order.bps),
+      order.deadline.toString(),
+      order.nonce,
+      ...toU256(order.min_fill_bps)
+    ];
+    return { contractAddress: this.address, entrypoint: "cancel_order", calldata };
+  }
+  buildCancelOrdersByNonce(minNonce) {
+    return {
+      contractAddress: this.address,
+      entrypoint: "cancel_orders_by_nonce",
+      calldata: [minNonce]
+    };
+  }
   // ── Execute Methods ────────────────────────────────────────────────
   /**
    * Execute one or more calls via the connected account.
@@ -2127,6 +2697,19 @@ var InscriptionClient = class {
   async redeem(inscriptionId, shares) {
     return this.execute([this.buildRedeem(inscriptionId, shares)]);
   }
+  async privateRedeem(request, proof) {
+    return this.execute([this.buildPrivateRedeem(request, proof)]);
+  }
+  async fillSignedOrder(order, signature, fillBps, approvals) {
+    const calls = [...approvals ?? [], this.buildFillSignedOrder(order, signature, fillBps)];
+    return this.execute(calls);
+  }
+  async cancelOrder(order) {
+    return this.execute([this.buildCancelOrder(order)]);
+  }
+  async cancelOrdersByNonce(minNonce) {
+    return this.execute([this.buildCancelOrdersByNonce(minNonce)]);
+  }
 };
 function serializeAssets(assets) {
   const calldata = [String(assets.length)];
@@ -2512,8 +3095,12 @@ exports.VALID_STATUSES = VALID_STATUSES;
 exports.VIRTUAL_SHARE_OFFSET = VIRTUAL_SHARE_OFFSET;
 exports.addressesEqual = addressesEqual;
 exports.calculateFeeShares = calculateFeeShares;
+exports.computeCommitment = computeCommitment;
+exports.computeDepositCommitment = computeDepositCommitment;
+exports.computeNullifier = computeNullifier;
 exports.computeStatus = computeStatus;
 exports.convertToShares = convertToShares;
+exports.createPrivateNote = createPrivateNote;
 exports.deserializeSignature = deserializeSignature;
 exports.findTokenByAddress = findTokenByAddress;
 exports.formatAddress = formatAddress;
@@ -2521,10 +3108,13 @@ exports.formatDuration = formatDuration;
 exports.formatTimestamp = formatTimestamp;
 exports.formatTokenValue = formatTokenValue;
 exports.fromU256 = fromU256;
+exports.generateSalt = generateSalt;
 exports.getInscriptionOrderTypedData = getInscriptionOrderTypedData;
 exports.getLendOfferTypedData = getLendOfferTypedData;
+exports.getPrivateLendOfferTypedData = getPrivateLendOfferTypedData;
 exports.getTokensForNetwork = getTokensForNetwork;
 exports.hashAssets = hashAssets;
+exports.hashPair = hashPair;
 exports.inscriptionIdToHex = inscriptionIdToHex;
 exports.normalizeAddress = normalizeAddress;
 exports.parseAmount = parseAmount;