@silvana-one/token 0.1.1 → 0.1.2

package/dist/node/index.cjs

@@ -48,7 +48,7 @@ module.exports = __toCommonJS(index_exports);
 
 // dist/node/bid.js
 var import_tslib4 = require("tslib");
-var import_o1js4 = require("o1js");
+var import_o1js5 = require("o1js");
 var import_storage2 = require("@silvana-one/storage");
 
 // dist/node/FungibleTokenContract.js
@@ -633,19 +633,55 @@ var FungibleTokenAdvancedAdmin = class extends import_o1js3.TokenContract {
 var FungibleToken = FungibleTokenContract(FungibleTokenAdmin);
 var AdvancedFungibleToken = FungibleTokenContract(FungibleTokenAdvancedAdmin);
 
+// dist/node/div.js
+var import_o1js4 = require("o1js");
+var MulDivResult = class extends (0, import_o1js4.Struct)({
+  result: import_o1js4.UInt64,
+  remainder: import_o1js4.UInt64
+}) {
+};
+var MulDivResultInternal = class extends (0, import_o1js4.Struct)({
+  result: import_o1js4.Field,
+  remainder: import_o1js4.Field
+}) {
+};
+function mulDiv(params) {
+  const { value, multiplier, denominator } = params;
+  denominator.equals(import_o1js4.UInt64.zero).assertFalse("division by zero");
+  const fields = import_o1js4.Provable.witness(MulDivResultInternal, () => {
+    const valueBigInt = value.toBigInt();
+    const multiplierBigInt = multiplier.toBigInt();
+    const denominatorBigInt = denominator.toBigInt();
+    if (denominatorBigInt === 0n) {
+      return { result: import_o1js4.Field.from(0n), remainder: import_o1js4.Field.from(0n) };
+    }
+    const result = valueBigInt * multiplierBigInt / denominatorBigInt;
+    const remainder = valueBigInt * multiplierBigInt - result * denominatorBigInt;
+    return { result: import_o1js4.Field.from(result), remainder: import_o1js4.Field.from(remainder) };
+  });
+  import_o1js4.Gadgets.rangeCheck64(fields.result);
+  import_o1js4.Gadgets.rangeCheck64(fields.remainder);
+  fields.remainder.assertLessThan(denominator.value);
+  fields.result.mul(denominator.value).add(fields.remainder).assertEquals(value.value.mul(multiplier.value));
+  return {
+    result: import_o1js4.UInt64.Unsafe.fromField(fields.result),
+    remainder: import_o1js4.UInt64.Unsafe.fromField(fields.remainder)
+  };
+}
+
 // dist/node/bid.js
-var BidEvent = class extends (0, import_o1js4.Struct)({
-  amount: import_o1js4.UInt64,
-  address: import_o1js4.PublicKey
+var BidEvent = class extends (0, import_o1js5.Struct)({
+  amount: import_o1js5.UInt64,
+  address: import_o1js5.PublicKey
 }) {
 };
-var FungibleTokenBidContract = class extends import_o1js4.SmartContract {
+var FungibleTokenBidContract = class extends import_o1js5.SmartContract {
   constructor() {
     super(...arguments);
-    this.price = (0, import_o1js4.State)();
-    this.buyer = (0, import_o1js4.State)();
-    this.token = (0, import_o1js4.State)();
-    this.whitelist = (0, import_o1js4.State)();
+    this.price = (0, import_o1js5.State)();
+    this.buyer = (0, import_o1js5.State)();
+    this.token = (0, import_o1js5.State)();
+    this.whitelist = (0, import_o1js5.State)();
     this.events = {
       bid: BidEvent,
       withdraw: BidEvent,
@@ -657,72 +693,78 @@ var FungibleTokenBidContract = class extends import_o1js4.SmartContract {
     await super.deploy(args);
     this.whitelist.set(args.whitelist);
     this.account.permissions.set({
-      ...import_o1js4.Permissions.default(),
-      send: import_o1js4.Permissions.proof(),
-      setVerificationKey: import_o1js4.Permissions.VerificationKey.impossibleDuringCurrentVersion(),
-      setPermissions: import_o1js4.Permissions.impossible()
+      ...import_o1js5.Permissions.default(),
+      send: import_o1js5.Permissions.proof(),
+      setVerificationKey: import_o1js5.Permissions.VerificationKey.impossibleDuringCurrentVersion(),
+      setPermissions: import_o1js5.Permissions.impossible()
     });
   }
   async initialize(token, amount, price) {
-    this.account.provedState.requireEquals((0, import_o1js4.Bool)(false));
-    amount.equals(import_o1js4.UInt64.from(0)).assertFalse();
-    const totalPriceField = price.value.mul(amount.value).div((0, import_o1js4.Field)(1e9));
-    totalPriceField.assertLessThan(import_o1js4.UInt64.MAXINT().value, "totalPrice overflow");
-    const totalPrice = import_o1js4.UInt64.Unsafe.fromField(totalPriceField);
+    this.account.provedState.requireEquals((0, import_o1js5.Bool)(false));
+    amount.equals(import_o1js5.UInt64.from(0)).assertFalse();
+    const totalPrice = mulDiv({
+      value: price,
+      multiplier: amount,
+      denominator: import_o1js5.UInt64.from(1e9)
+    }).result;
     const buyer = this.sender.getUnconstrained();
-    const buyerUpdate = import_o1js4.AccountUpdate.createSigned(buyer);
+    const buyerUpdate = import_o1js5.AccountUpdate.createSigned(buyer);
     buyerUpdate.send({ to: this.address, amount: totalPrice });
-    buyerUpdate.body.useFullCommitment = (0, import_o1js4.Bool)(true);
+    buyerUpdate.body.useFullCommitment = (0, import_o1js5.Bool)(true);
     this.buyer.set(buyer);
     this.price.set(price);
     this.token.set(token);
     this.emitEvent("bid", { amount, address: buyer });
   }
   async bid(amount, price) {
-    amount.equals(import_o1js4.UInt64.from(0)).assertFalse();
+    amount.equals(import_o1js5.UInt64.from(0)).assertFalse();
     const balance = this.account.balance.getAndRequireEquals();
     const oldPrice = this.price.getAndRequireEquals();
-    price.equals(oldPrice).or(balance.equals(import_o1js4.UInt64.from(0))).assertTrue();
+    price.equals(oldPrice).or(balance.equals(import_o1js5.UInt64.from(0))).assertTrue();
     this.price.set(price);
-    const totalPriceField = price.value.mul(amount.value).div((0, import_o1js4.Field)(1e9));
-    totalPriceField.assertLessThan(import_o1js4.UInt64.MAXINT().value, "totalPrice overflow");
-    const totalPrice = import_o1js4.UInt64.Unsafe.fromField(totalPriceField);
+    const totalPrice = mulDiv({
+      value: price,
+      multiplier: amount,
+      denominator: import_o1js5.UInt64.from(1e9)
+    }).result;
     const sender = this.sender.getUnconstrained();
     const buyer = this.buyer.getAndRequireEquals();
     sender.assertEquals(buyer);
-    const buyerUpdate = import_o1js4.AccountUpdate.createSigned(buyer);
+    const buyerUpdate = import_o1js5.AccountUpdate.createSigned(buyer);
     buyerUpdate.send({ to: this.address, amount: totalPrice });
-    buyerUpdate.body.useFullCommitment = (0, import_o1js4.Bool)(true);
+    buyerUpdate.body.useFullCommitment = (0, import_o1js5.Bool)(true);
     this.price.set(price);
     this.emitEvent("bid", { amount, address: buyer });
   }
   async withdraw(amountInMina) {
-    amountInMina.equals(import_o1js4.UInt64.from(0)).assertFalse();
-    this.account.balance.requireBetween(amountInMina, import_o1js4.UInt64.MAXINT());
+    amountInMina.equals(import_o1js5.UInt64.from(0)).assertFalse();
+    this.account.balance.requireBetween(amountInMina, import_o1js5.UInt64.MAXINT());
     const buyer = this.buyer.getAndRequireEquals();
     const sender = this.sender.getUnconstrained();
-    const senderUpdate = import_o1js4.AccountUpdate.createSigned(sender);
-    senderUpdate.body.useFullCommitment = (0, import_o1js4.Bool)(true);
+    const senderUpdate = import_o1js5.AccountUpdate.createSigned(sender);
+    senderUpdate.body.useFullCommitment = (0, import_o1js5.Bool)(true);
     sender.assertEquals(buyer);
     let bidUpdate = this.send({ to: senderUpdate, amount: amountInMina });
-    bidUpdate.body.useFullCommitment = (0, import_o1js4.Bool)(true);
+    bidUpdate.body.useFullCommitment = (0, import_o1js5.Bool)(true);
     this.emitEvent("withdraw", {
       amount: amountInMina,
       address: buyer
     });
   }
   async sell(amount) {
-    amount.equals(import_o1js4.UInt64.from(0)).assertFalse();
+    amount.equals(import_o1js5.UInt64.from(0)).assertFalse();
     const price = this.price.getAndRequireEquals();
-    const totalPriceField = price.value.mul(amount.value).div((0, import_o1js4.Field)(1e9));
-    totalPriceField.assertLessThan(import_o1js4.UInt64.MAXINT().value, "totalPrice overflow");
-    const totalPrice = import_o1js4.UInt64.Unsafe.fromField(totalPriceField);
-    this.account.balance.requireBetween(totalPrice, import_o1js4.UInt64.MAXINT());
+    const totalPrice = mulDiv({
+      value: price,
+      multiplier: amount,
+      denominator: import_o1js5.UInt64.from(1e9)
+    }).result;
+    this.account.balance.requireBetween(totalPrice, import_o1js5.UInt64.MAXINT());
     const buyer = this.buyer.getAndRequireEquals();
     const token = this.token.getAndRequireEquals();
     const seller = this.sender.getUnconstrained();
     const sellerUpdate = this.send({ to: seller, amount: totalPrice });
-    sellerUpdate.body.useFullCommitment = (0, import_o1js4.Bool)(true);
+    sellerUpdate.body.useFullCommitment = (0, import_o1js5.Bool)(true);
     sellerUpdate.requireSignature();
     const tokenContract = new FungibleToken(token);
     await tokenContract.transfer(seller, buyer, amount);
@@ -734,55 +776,55 @@ var FungibleTokenBidContract = class extends import_o1js4.SmartContract {
   async updateWhitelist(whitelist) {
     const buyer = this.buyer.getAndRequireEquals();
     const sender = this.sender.getUnconstrained();
-    const senderUpdate = import_o1js4.AccountUpdate.createSigned(sender);
-    senderUpdate.body.useFullCommitment = (0, import_o1js4.Bool)(true);
+    const senderUpdate = import_o1js5.AccountUpdate.createSigned(sender);
+    senderUpdate.body.useFullCommitment = (0, import_o1js5.Bool)(true);
     sender.assertEquals(buyer);
     this.whitelist.set(whitelist);
     this.emitEvent("updateWhitelist", whitelist);
   }
 };
 (0, import_tslib4.__decorate)([
-  (0, import_o1js4.state)(import_o1js4.UInt64),
+  (0, import_o1js5.state)(import_o1js5.UInt64),
   (0, import_tslib4.__metadata)("design:type", Object)
 ], FungibleTokenBidContract.prototype, "price", void 0);
 (0, import_tslib4.__decorate)([
-  (0, import_o1js4.state)(import_o1js4.PublicKey),
+  (0, import_o1js5.state)(import_o1js5.PublicKey),
   (0, import_tslib4.__metadata)("design:type", Object)
 ], FungibleTokenBidContract.prototype, "buyer", void 0);
 (0, import_tslib4.__decorate)([
-  (0, import_o1js4.state)(import_o1js4.PublicKey),
+  (0, import_o1js5.state)(import_o1js5.PublicKey),
   (0, import_tslib4.__metadata)("design:type", Object)
 ], FungibleTokenBidContract.prototype, "token", void 0);
 (0, import_tslib4.__decorate)([
-  (0, import_o1js4.state)(import_storage2.Whitelist),
+  (0, import_o1js5.state)(import_storage2.Whitelist),
   (0, import_tslib4.__metadata)("design:type", Object)
 ], FungibleTokenBidContract.prototype, "whitelist", void 0);
 (0, import_tslib4.__decorate)([
-  import_o1js4.method,
+  import_o1js5.method,
   (0, import_tslib4.__metadata)("design:type", Function),
-  (0, import_tslib4.__metadata)("design:paramtypes", [import_o1js4.PublicKey, import_o1js4.UInt64, import_o1js4.UInt64]),
+  (0, import_tslib4.__metadata)("design:paramtypes", [import_o1js5.PublicKey, import_o1js5.UInt64, import_o1js5.UInt64]),
   (0, import_tslib4.__metadata)("design:returntype", Promise)
 ], FungibleTokenBidContract.prototype, "initialize", null);
 (0, import_tslib4.__decorate)([
-  import_o1js4.method,
+  import_o1js5.method,
   (0, import_tslib4.__metadata)("design:type", Function),
-  (0, import_tslib4.__metadata)("design:paramtypes", [import_o1js4.UInt64, import_o1js4.UInt64]),
+  (0, import_tslib4.__metadata)("design:paramtypes", [import_o1js5.UInt64, import_o1js5.UInt64]),
   (0, import_tslib4.__metadata)("design:returntype", Promise)
 ], FungibleTokenBidContract.prototype, "bid", null);
 (0, import_tslib4.__decorate)([
-  import_o1js4.method,
+  import_o1js5.method,
   (0, import_tslib4.__metadata)("design:type", Function),
-  (0, import_tslib4.__metadata)("design:paramtypes", [import_o1js4.UInt64]),
+  (0, import_tslib4.__metadata)("design:paramtypes", [import_o1js5.UInt64]),
   (0, import_tslib4.__metadata)("design:returntype", Promise)
 ], FungibleTokenBidContract.prototype, "withdraw", null);
 (0, import_tslib4.__decorate)([
-  import_o1js4.method,
+  import_o1js5.method,
   (0, import_tslib4.__metadata)("design:type", Function),
-  (0, import_tslib4.__metadata)("design:paramtypes", [import_o1js4.UInt64]),
+  (0, import_tslib4.__metadata)("design:paramtypes", [import_o1js5.UInt64]),
   (0, import_tslib4.__metadata)("design:returntype", Promise)
 ], FungibleTokenBidContract.prototype, "sell", null);
 (0, import_tslib4.__decorate)([
-  import_o1js4.method,
+  import_o1js5.method,
   (0, import_tslib4.__metadata)("design:type", Function),
   (0, import_tslib4.__metadata)("design:paramtypes", [import_storage2.Whitelist]),
   (0, import_tslib4.__metadata)("design:returntype", Promise)
@@ -790,20 +832,20 @@ var FungibleTokenBidContract = class extends import_o1js4.SmartContract {
 
 // dist/node/claim.js
 var import_tslib5 = require("tslib");
-var import_o1js5 = require("o1js");
+var import_o1js6 = require("o1js");
 var import_storage3 = require("@silvana-one/storage");
-var ClaimEvent = class extends (0, import_o1js5.Struct)({
-  amount: import_o1js5.UInt64,
-  address: import_o1js5.PublicKey
+var ClaimEvent = class extends (0, import_o1js6.Struct)({
+  amount: import_o1js6.UInt64,
+  address: import_o1js6.PublicKey
 }) {
 };
-var FungibleTokenClaimContract = class extends import_o1js5.SmartContract {
+var FungibleTokenClaimContract = class extends import_o1js6.SmartContract {
   constructor() {
     super(...arguments);
-    this.owner = (0, import_o1js5.State)();
-    this.token = (0, import_o1js5.State)();
-    this.whitelist = (0, import_o1js5.State)();
-    this.maxAmount = (0, import_o1js5.State)();
+    this.owner = (0, import_o1js6.State)();
+    this.token = (0, import_o1js6.State)();
+    this.whitelist = (0, import_o1js6.State)();
+    this.maxAmount = (0, import_o1js6.State)();
     this.events = {
       offer: ClaimEvent,
       withdraw: ClaimEvent,
@@ -814,16 +856,16 @@ var FungibleTokenClaimContract = class extends import_o1js5.SmartContract {
   async deploy(args) {
     await super.deploy(args);
     this.whitelist.set(args.whitelist);
-    this.maxAmount.set(args.maxAmount ?? import_o1js5.UInt64.MAXINT());
+    this.maxAmount.set(args.maxAmount ?? import_o1js6.UInt64.MAXINT());
     this.account.permissions.set({
-      ...import_o1js5.Permissions.default(),
-      send: import_o1js5.Permissions.proof(),
-      setVerificationKey: import_o1js5.Permissions.VerificationKey.impossibleDuringCurrentVersion(),
-      setPermissions: import_o1js5.Permissions.impossible()
+      ...import_o1js6.Permissions.default(),
+      send: import_o1js6.Permissions.proof(),
+      setVerificationKey: import_o1js6.Permissions.VerificationKey.impossibleDuringCurrentVersion(),
+      setPermissions: import_o1js6.Permissions.impossible()
     });
   }
   async initialize(owner, token, amount) {
-    this.account.provedState.requireEquals((0, import_o1js5.Bool)(false));
+    this.account.provedState.requireEquals((0, import_o1js6.Bool)(false));
     const tokenContract = new FungibleToken(token);
     const tokenId = tokenContract.deriveTokenId();
     tokenId.assertEquals(this.tokenId);
@@ -839,27 +881,27 @@ var FungibleTokenClaimContract = class extends import_o1js5.SmartContract {
     const tokenId = tokenContract.deriveTokenId();
     tokenId.assertEquals(this.tokenId);
     const sender = this.sender.getUnconstrained();
-    const senderUpdate = import_o1js5.AccountUpdate.createSigned(sender);
-    senderUpdate.body.useFullCommitment = (0, import_o1js5.Bool)(true);
+    const senderUpdate = import_o1js6.AccountUpdate.createSigned(sender);
+    senderUpdate.body.useFullCommitment = (0, import_o1js6.Bool)(true);
     sender.assertEquals(owner);
     await tokenContract.transfer(sender, this.address, amount);
     this.emitEvent("offer", { amount, address: sender });
   }
   async withdraw(amount) {
-    amount.equals(import_o1js5.UInt64.from(0)).assertFalse();
-    this.account.balance.requireBetween(amount, import_o1js5.UInt64.MAXINT());
+    amount.equals(import_o1js6.UInt64.from(0)).assertFalse();
+    this.account.balance.requireBetween(amount, import_o1js6.UInt64.MAXINT());
     const owner = this.owner.getAndRequireEquals();
     const token = this.token.getAndRequireEquals();
     const tokenContract = new FungibleToken(token);
     const tokenId = tokenContract.deriveTokenId();
     tokenId.assertEquals(this.tokenId);
     const sender = this.sender.getUnconstrained();
-    const senderUpdate = import_o1js5.AccountUpdate.createSigned(sender, tokenId);
-    senderUpdate.body.useFullCommitment = (0, import_o1js5.Bool)(true);
+    const senderUpdate = import_o1js6.AccountUpdate.createSigned(sender, tokenId);
+    senderUpdate.body.useFullCommitment = (0, import_o1js6.Bool)(true);
     sender.assertEquals(owner);
     let offerUpdate = this.send({ to: senderUpdate, amount });
-    offerUpdate.body.mayUseToken = import_o1js5.AccountUpdate.MayUseToken.InheritFromParent;
-    offerUpdate.body.useFullCommitment = (0, import_o1js5.Bool)(true);
+    offerUpdate.body.mayUseToken = import_o1js6.AccountUpdate.MayUseToken.InheritFromParent;
+    offerUpdate.body.useFullCommitment = (0, import_o1js6.Bool)(true);
     this.emitEvent("withdraw", { amount, address: sender });
   }
   async claim(amount) {
@@ -869,16 +911,16 @@ var FungibleTokenClaimContract = class extends import_o1js5.SmartContract {
     const tokenId = tokenContract.deriveTokenId();
     tokenId.assertEquals(this.tokenId);
     const sender = this.sender.getUnconstrained();
-    const senderUpdate = import_o1js5.AccountUpdate.createSigned(sender, tokenId);
-    senderUpdate.body.useFullCommitment = (0, import_o1js5.Bool)(true);
+    const senderUpdate = import_o1js6.AccountUpdate.createSigned(sender, tokenId);
+    senderUpdate.body.useFullCommitment = (0, import_o1js6.Bool)(true);
     const whitelist = this.whitelist.getAndRequireEquals();
     const whiteListedAmount = await whitelist.getWhitelistedAmount(sender);
-    const maxClaimAmount = import_o1js5.Provable.if(whitelist.isSome(), whiteListedAmount.assertSome("No tokens to claim"), maxAmount);
+    const maxClaimAmount = import_o1js6.Provable.if(whitelist.isSome(), whiteListedAmount.assertSome("No tokens to claim"), maxAmount);
     amount.assertLessThanOrEqual(maxClaimAmount);
-    this.account.balance.requireBetween(amount, import_o1js5.UInt64.MAXINT());
+    this.account.balance.requireBetween(amount, import_o1js6.UInt64.MAXINT());
     let offerUpdate = this.send({ to: senderUpdate, amount });
-    offerUpdate.body.mayUseToken = import_o1js5.AccountUpdate.MayUseToken.InheritFromParent;
-    offerUpdate.body.useFullCommitment = (0, import_o1js5.Bool)(true);
+    offerUpdate.body.mayUseToken = import_o1js6.AccountUpdate.MayUseToken.InheritFromParent;
+    offerUpdate.body.useFullCommitment = (0, import_o1js6.Bool)(true);
     this.emitEvent("claim", {
       amount,
       address: sender
@@ -887,59 +929,59 @@ var FungibleTokenClaimContract = class extends import_o1js5.SmartContract {
   async updateWhitelist(whitelist) {
     const owner = this.owner.getAndRequireEquals();
     const sender = this.sender.getUnconstrained();
-    const senderUpdate = import_o1js5.AccountUpdate.createSigned(sender);
-    senderUpdate.body.useFullCommitment = (0, import_o1js5.Bool)(true);
+    const senderUpdate = import_o1js6.AccountUpdate.createSigned(sender);
+    senderUpdate.body.useFullCommitment = (0, import_o1js6.Bool)(true);
     sender.assertEquals(owner);
     this.whitelist.set(whitelist);
     this.emitEvent("updateWhitelist", whitelist);
   }
 };
 (0, import_tslib5.__decorate)([
-  (0, import_o1js5.state)(import_o1js5.PublicKey),
+  (0, import_o1js6.state)(import_o1js6.PublicKey),
   (0, import_tslib5.__metadata)("design:type", Object)
 ], FungibleTokenClaimContract.prototype, "owner", void 0);
 (0, import_tslib5.__decorate)([
-  (0, import_o1js5.state)(import_o1js5.PublicKey),
+  (0, import_o1js6.state)(import_o1js6.PublicKey),
   (0, import_tslib5.__metadata)("design:type", Object)
 ], FungibleTokenClaimContract.prototype, "token", void 0);
 (0, import_tslib5.__decorate)([
-  (0, import_o1js5.state)(import_storage3.Whitelist),
+  (0, import_o1js6.state)(import_storage3.Whitelist),
   (0, import_tslib5.__metadata)("design:type", Object)
 ], FungibleTokenClaimContract.prototype, "whitelist", void 0);
 (0, import_tslib5.__decorate)([
-  (0, import_o1js5.state)(import_o1js5.UInt64),
+  (0, import_o1js6.state)(import_o1js6.UInt64),
   (0, import_tslib5.__metadata)("design:type", Object)
 ], FungibleTokenClaimContract.prototype, "maxAmount", void 0);
 (0, import_tslib5.__decorate)([
-  import_o1js5.method,
+  import_o1js6.method,
   (0, import_tslib5.__metadata)("design:type", Function),
   (0, import_tslib5.__metadata)("design:paramtypes", [
-    import_o1js5.PublicKey,
-    import_o1js5.PublicKey,
-    import_o1js5.UInt64
+    import_o1js6.PublicKey,
+    import_o1js6.PublicKey,
+    import_o1js6.UInt64
   ]),
   (0, import_tslib5.__metadata)("design:returntype", Promise)
 ], FungibleTokenClaimContract.prototype, "initialize", null);
 (0, import_tslib5.__decorate)([
-  import_o1js5.method,
+  import_o1js6.method,
   (0, import_tslib5.__metadata)("design:type", Function),
-  (0, import_tslib5.__metadata)("design:paramtypes", [import_o1js5.UInt64]),
+  (0, import_tslib5.__metadata)("design:paramtypes", [import_o1js6.UInt64]),
   (0, import_tslib5.__metadata)("design:returntype", Promise)
 ], FungibleTokenClaimContract.prototype, "offer", null);
 (0, import_tslib5.__decorate)([
-  import_o1js5.method,
+  import_o1js6.method,
   (0, import_tslib5.__metadata)("design:type", Function),
-  (0, import_tslib5.__metadata)("design:paramtypes", [import_o1js5.UInt64]),
+  (0, import_tslib5.__metadata)("design:paramtypes", [import_o1js6.UInt64]),
   (0, import_tslib5.__metadata)("design:returntype", Promise)
 ], FungibleTokenClaimContract.prototype, "withdraw", null);
 (0, import_tslib5.__decorate)([
-  import_o1js5.method,
+  import_o1js6.method,
   (0, import_tslib5.__metadata)("design:type", Function),
-  (0, import_tslib5.__metadata)("design:paramtypes", [import_o1js5.UInt64]),
+  (0, import_tslib5.__metadata)("design:paramtypes", [import_o1js6.UInt64]),
   (0, import_tslib5.__metadata)("design:returntype", Promise)
 ], FungibleTokenClaimContract.prototype, "claim", null);
 (0, import_tslib5.__decorate)([
-  import_o1js5.method,
+  import_o1js6.method,
   (0, import_tslib5.__metadata)("design:type", Function),
   (0, import_tslib5.__metadata)("design:paramtypes", [import_storage3.Whitelist]),
   (0, import_tslib5.__metadata)("design:returntype", Promise)
@@ -947,20 +989,20 @@ var FungibleTokenClaimContract = class extends import_o1js5.SmartContract {
 
 // dist/node/offer.js
 var import_tslib6 = require("tslib");
-var import_o1js6 = require("o1js");
+var import_o1js7 = require("o1js");
 var import_storage4 = require("@silvana-one/storage");
-var OfferEvent = class extends (0, import_o1js6.Struct)({
-  amount: import_o1js6.UInt64,
-  address: import_o1js6.PublicKey
+var OfferEvent = class extends (0, import_o1js7.Struct)({
+  amount: import_o1js7.UInt64,
+  address: import_o1js7.PublicKey
 }) {
 };
-var FungibleTokenOfferContract = class extends import_o1js6.SmartContract {
+var FungibleTokenOfferContract = class extends import_o1js7.SmartContract {
   constructor() {
     super(...arguments);
-    this.price = (0, import_o1js6.State)();
-    this.seller = (0, import_o1js6.State)();
-    this.token = (0, import_o1js6.State)();
-    this.whitelist = (0, import_o1js6.State)();
+    this.price = (0, import_o1js7.State)();
+    this.seller = (0, import_o1js7.State)();
+    this.token = (0, import_o1js7.State)();
+    this.whitelist = (0, import_o1js7.State)();
     this.events = {
       offer: OfferEvent,
       withdraw: OfferEvent,
@@ -972,14 +1014,14 @@ var FungibleTokenOfferContract = class extends import_o1js6.SmartContract {
     await super.deploy(args);
     this.whitelist.set(args.whitelist);
     this.account.permissions.set({
-      ...import_o1js6.Permissions.default(),
-      send: import_o1js6.Permissions.proof(),
-      setVerificationKey: import_o1js6.Permissions.VerificationKey.impossibleDuringCurrentVersion(),
-      setPermissions: import_o1js6.Permissions.impossible()
+      ...import_o1js7.Permissions.default(),
+      send: import_o1js7.Permissions.proof(),
+      setVerificationKey: import_o1js7.Permissions.VerificationKey.impossibleDuringCurrentVersion(),
+      setPermissions: import_o1js7.Permissions.impossible()
     });
   }
   async initialize(seller, token, amount, price) {
-    this.account.provedState.requireEquals((0, import_o1js6.Bool)(false));
+    this.account.provedState.requireEquals((0, import_o1js7.Bool)(false));
     const tokenContract = new FungibleToken(token);
     const tokenId = tokenContract.deriveTokenId();
     tokenId.assertEquals(this.tokenId);
@@ -997,51 +1039,53 @@ var FungibleTokenOfferContract = class extends import_o1js6.SmartContract {
     tokenId.assertEquals(this.tokenId);
     const balance = this.account.balance.getAndRequireEquals();
     const oldPrice = this.price.getAndRequireEquals();
-    price.equals(oldPrice).or(balance.equals(import_o1js6.UInt64.from(0))).assertTrue();
+    price.equals(oldPrice).or(balance.equals(import_o1js7.UInt64.from(0))).assertTrue();
     this.price.set(price);
     const sender = this.sender.getUnconstrained();
-    const senderUpdate = import_o1js6.AccountUpdate.createSigned(sender);
-    senderUpdate.body.useFullCommitment = (0, import_o1js6.Bool)(true);
+    const senderUpdate = import_o1js7.AccountUpdate.createSigned(sender);
+    senderUpdate.body.useFullCommitment = (0, import_o1js7.Bool)(true);
     sender.assertEquals(seller);
     await tokenContract.transfer(sender, this.address, amount);
     this.emitEvent("offer", { amount, address: sender });
   }
   async withdraw(amount) {
-    amount.equals(import_o1js6.UInt64.from(0)).assertFalse();
-    this.account.balance.requireBetween(amount, import_o1js6.UInt64.MAXINT());
+    amount.equals(import_o1js7.UInt64.from(0)).assertFalse();
+    this.account.balance.requireBetween(amount, import_o1js7.UInt64.MAXINT());
     const seller = this.seller.getAndRequireEquals();
     const token = this.token.getAndRequireEquals();
     const tokenContract = new FungibleToken(token);
     const tokenId = tokenContract.deriveTokenId();
     tokenId.assertEquals(this.tokenId);
     const sender = this.sender.getUnconstrained();
-    const senderUpdate = import_o1js6.AccountUpdate.createSigned(sender, tokenId);
-    senderUpdate.body.useFullCommitment = (0, import_o1js6.Bool)(true);
+    const senderUpdate = import_o1js7.AccountUpdate.createSigned(sender, tokenId);
+    senderUpdate.body.useFullCommitment = (0, import_o1js7.Bool)(true);
     sender.assertEquals(seller);
     let offerUpdate = this.send({ to: senderUpdate, amount });
-    offerUpdate.body.mayUseToken = import_o1js6.AccountUpdate.MayUseToken.InheritFromParent;
-    offerUpdate.body.useFullCommitment = (0, import_o1js6.Bool)(true);
+    offerUpdate.body.mayUseToken = import_o1js7.AccountUpdate.MayUseToken.InheritFromParent;
+    offerUpdate.body.useFullCommitment = (0, import_o1js7.Bool)(true);
     this.emitEvent("withdraw", { amount, address: sender });
   }
   async buy(amount) {
-    amount.equals(import_o1js6.UInt64.from(0)).assertFalse();
-    this.account.balance.requireBetween(amount, import_o1js6.UInt64.MAXINT());
+    amount.equals(import_o1js7.UInt64.from(0)).assertFalse();
+    this.account.balance.requireBetween(amount, import_o1js7.UInt64.MAXINT());
     const seller = this.seller.getAndRequireEquals();
     const token = this.token.getAndRequireEquals();
     const tokenContract = new FungibleToken(token);
     const tokenId = tokenContract.deriveTokenId();
     tokenId.assertEquals(this.tokenId);
     const price = this.price.getAndRequireEquals();
-    const totalPriceField = price.value.mul(amount.value).div((0, import_o1js6.Field)(1e9));
-    totalPriceField.assertLessThan(import_o1js6.UInt64.MAXINT().value, "totalPrice overflow");
-    const totalPrice = import_o1js6.UInt64.Unsafe.fromField(totalPriceField);
+    const totalPrice = mulDiv({
+      value: price,
+      multiplier: amount,
+      denominator: import_o1js7.UInt64.from(1e9)
+    }).result;
     const buyer = this.sender.getUnconstrained();
-    const buyerUpdate = import_o1js6.AccountUpdate.createSigned(buyer);
+    const buyerUpdate = import_o1js7.AccountUpdate.createSigned(buyer);
     buyerUpdate.send({ to: seller, amount: totalPrice });
-    buyerUpdate.body.useFullCommitment = (0, import_o1js6.Bool)(true);
+    buyerUpdate.body.useFullCommitment = (0, import_o1js7.Bool)(true);
     let offerUpdate = this.send({ to: buyer, amount });
-    offerUpdate.body.mayUseToken = import_o1js6.AccountUpdate.MayUseToken.InheritFromParent;
-    offerUpdate.body.useFullCommitment = (0, import_o1js6.Bool)(true);
+    offerUpdate.body.mayUseToken = import_o1js7.AccountUpdate.MayUseToken.InheritFromParent;
+    offerUpdate.body.useFullCommitment = (0, import_o1js7.Bool)(true);
     const whitelist = this.whitelist.getAndRequireEquals();
     const whitelistedAmount = await whitelist.getWhitelistedAmount(buyer);
     amount.assertLessThanOrEqual(whitelistedAmount.assertSome("Cannot buy more than whitelisted amount"));
@@ -1050,60 +1094,60 @@ var FungibleTokenOfferContract = class extends import_o1js6.SmartContract {
   async updateWhitelist(whitelist) {
     const seller = this.seller.getAndRequireEquals();
     const sender = this.sender.getUnconstrained();
-    const senderUpdate = import_o1js6.AccountUpdate.createSigned(sender);
-    senderUpdate.body.useFullCommitment = (0, import_o1js6.Bool)(true);
+    const senderUpdate = import_o1js7.AccountUpdate.createSigned(sender);
+    senderUpdate.body.useFullCommitment = (0, import_o1js7.Bool)(true);
     sender.assertEquals(seller);
     this.whitelist.set(whitelist);
     this.emitEvent("updateWhitelist", whitelist);
   }
 };
 (0, import_tslib6.__decorate)([
-  (0, import_o1js6.state)(import_o1js6.UInt64),
+  (0, import_o1js7.state)(import_o1js7.UInt64),
   (0, import_tslib6.__metadata)("design:type", Object)
 ], FungibleTokenOfferContract.prototype, "price", void 0);
 (0, import_tslib6.__decorate)([
-  (0, import_o1js6.state)(import_o1js6.PublicKey),
+  (0, import_o1js7.state)(import_o1js7.PublicKey),
   (0, import_tslib6.__metadata)("design:type", Object)
 ], FungibleTokenOfferContract.prototype, "seller", void 0);
 (0, import_tslib6.__decorate)([
-  (0, import_o1js6.state)(import_o1js6.PublicKey),
+  (0, import_o1js7.state)(import_o1js7.PublicKey),
   (0, import_tslib6.__metadata)("design:type", Object)
 ], FungibleTokenOfferContract.prototype, "token", void 0);
 (0, import_tslib6.__decorate)([
-  (0, import_o1js6.state)(import_storage4.Whitelist),
+  (0, import_o1js7.state)(import_storage4.Whitelist),
   (0, import_tslib6.__metadata)("design:type", Object)
 ], FungibleTokenOfferContract.prototype, "whitelist", void 0);
 (0, import_tslib6.__decorate)([
-  import_o1js6.method,
+  import_o1js7.method,
   (0, import_tslib6.__metadata)("design:type", Function),
   (0, import_tslib6.__metadata)("design:paramtypes", [
-    import_o1js6.PublicKey,
-    import_o1js6.PublicKey,
-    import_o1js6.UInt64,
-    import_o1js6.UInt64
+    import_o1js7.PublicKey,
+    import_o1js7.PublicKey,
+    import_o1js7.UInt64,
+    import_o1js7.UInt64
   ]),
   (0, import_tslib6.__metadata)("design:returntype", Promise)
 ], FungibleTokenOfferContract.prototype, "initialize", null);
 (0, import_tslib6.__decorate)([
-  import_o1js6.method,
+  import_o1js7.method,
   (0, import_tslib6.__metadata)("design:type", Function),
-  (0, import_tslib6.__metadata)("design:paramtypes", [import_o1js6.UInt64, import_o1js6.UInt64]),
+  (0, import_tslib6.__metadata)("design:paramtypes", [import_o1js7.UInt64, import_o1js7.UInt64]),
   (0, import_tslib6.__metadata)("design:returntype", Promise)
 ], FungibleTokenOfferContract.prototype, "offer", null);
 (0, import_tslib6.__decorate)([
-  import_o1js6.method,
+  import_o1js7.method,
   (0, import_tslib6.__metadata)("design:type", Function),
-  (0, import_tslib6.__metadata)("design:paramtypes", [import_o1js6.UInt64]),
+  (0, import_tslib6.__metadata)("design:paramtypes", [import_o1js7.UInt64]),
   (0, import_tslib6.__metadata)("design:returntype", Promise)
 ], FungibleTokenOfferContract.prototype, "withdraw", null);
 (0, import_tslib6.__decorate)([
-  import_o1js6.method,
+  import_o1js7.method,
   (0, import_tslib6.__metadata)("design:type", Function),
-  (0, import_tslib6.__metadata)("design:paramtypes", [import_o1js6.UInt64]),
+  (0, import_tslib6.__metadata)("design:paramtypes", [import_o1js7.UInt64]),
   (0, import_tslib6.__metadata)("design:returntype", Promise)
 ], FungibleTokenOfferContract.prototype, "buy", null);
 (0, import_tslib6.__decorate)([
-  import_o1js6.method,
+  import_o1js7.method,
   (0, import_tslib6.__metadata)("design:type", Function),
   (0, import_tslib6.__metadata)("design:paramtypes", [import_storage4.Whitelist]),
   (0, import_tslib6.__metadata)("design:returntype", Promise)
@@ -1111,17 +1155,17 @@ var FungibleTokenOfferContract = class extends import_o1js6.SmartContract {
 
 // dist/node/BondingCurveAdmin.js
 var import_tslib7 = require("tslib");
-var import_o1js7 = require("o1js");
+var import_o1js8 = require("o1js");
 var import_token = require("@silvana-one/token");
-var BondingCurveParams = class _BondingCurveParams extends (0, import_o1js7.Struct)({
-  startPrice: import_o1js7.UInt64,
-  curveK: import_o1js7.UInt64,
-  fee: import_o1js7.UInt32,
+var BondingCurveParams = class _BondingCurveParams extends (0, import_o1js8.Struct)({
+  startPrice: import_o1js8.UInt64,
+  curveK: import_o1js8.UInt64,
+  fee: import_o1js8.UInt32,
   // 1000 = 1%
-  mintingIsAllowed: import_o1js7.Bool
+  mintingIsAllowed: import_o1js8.Bool
 }) {
   pack() {
-    return import_o1js7.Field.fromBits([
+    return import_o1js8.Field.fromBits([
       ...this.startPrice.value.toBits(64),
       ...this.curveK.value.toBits(64),
       ...this.fee.value.toBits(32),
@@ -1130,9 +1174,9 @@ var BondingCurveParams = class _BondingCurveParams extends (0, import_o1js7.Stru
   }
   static unpack(field) {
     const bits = field.toBits(64 + 64 + 32 + 1);
-    const startPrice = import_o1js7.UInt64.Unsafe.fromField(import_o1js7.Field.fromBits(bits.slice(0, 64)));
-    const curveK = import_o1js7.UInt64.Unsafe.fromField(import_o1js7.Field.fromBits(bits.slice(64, 64 + 64)));
-    const fee = import_o1js7.UInt32.Unsafe.fromField(import_o1js7.Field.fromBits(bits.slice(64 + 64, 64 + 64 + 32)));
+    const startPrice = import_o1js8.UInt64.Unsafe.fromField(import_o1js8.Field.fromBits(bits.slice(0, 64)));
+    const curveK = import_o1js8.UInt64.Unsafe.fromField(import_o1js8.Field.fromBits(bits.slice(64, 64 + 64)));
+    const fee = import_o1js8.UInt32.Unsafe.fromField(import_o1js8.Field.fromBits(bits.slice(64 + 64, 64 + 64 + 32)));
     const mintingIsAllowed = bits[64 + 64 + 32];
     return new _BondingCurveParams({
       startPrice,
@@ -1142,42 +1186,42 @@ var BondingCurveParams = class _BondingCurveParams extends (0, import_o1js7.Stru
     });
   }
 };
-var BondingMintEvent = class extends (0, import_o1js7.Struct)({
-  to: import_o1js7.PublicKey,
-  amount: import_o1js7.UInt64,
-  price: import_o1js7.UInt64,
-  payment: import_o1js7.UInt64,
-  fee: import_o1js7.UInt64
+var BondingMintEvent = class extends (0, import_o1js8.Struct)({
+  to: import_o1js8.PublicKey,
+  amount: import_o1js8.UInt64,
+  price: import_o1js8.UInt64,
+  payment: import_o1js8.UInt64,
+  fee: import_o1js8.UInt64
 }) {
 };
-var BondingRedeemEvent = class extends (0, import_o1js7.Struct)({
-  seller: import_o1js7.PublicKey,
-  amount: import_o1js7.UInt64,
-  payment: import_o1js7.UInt64,
-  minBalance: import_o1js7.UInt64,
-  maxSupply: import_o1js7.UInt64,
-  fee: import_o1js7.UInt64
+var BondingRedeemEvent = class extends (0, import_o1js8.Struct)({
+  seller: import_o1js8.PublicKey,
+  amount: import_o1js8.UInt64,
+  payment: import_o1js8.UInt64,
+  minBalance: import_o1js8.UInt64,
+  maxSupply: import_o1js8.UInt64,
+  fee: import_o1js8.UInt64
 }) {
 };
-var BondingCurveAdminInitializeProps = class extends (0, import_o1js7.Struct)({
-  tokenAddress: import_o1js7.PublicKey,
-  startPrice: import_o1js7.UInt64,
-  curveK: import_o1js7.UInt64,
-  feeMaster: import_o1js7.PublicKey,
-  fee: import_o1js7.UInt32,
+var BondingCurveAdminInitializeProps = class extends (0, import_o1js8.Struct)({
+  tokenAddress: import_o1js8.PublicKey,
+  startPrice: import_o1js8.UInt64,
+  curveK: import_o1js8.UInt64,
+  feeMaster: import_o1js8.PublicKey,
+  fee: import_o1js8.UInt32,
   // 1000 = 1%
-  launchFee: import_o1js7.UInt64,
-  numberOfNewAccounts: import_o1js7.UInt64
+  launchFee: import_o1js8.UInt64,
+  numberOfNewAccounts: import_o1js8.UInt64
 }) {
 };
-var FungibleTokenBondingCurveAdmin = class extends import_o1js7.TokenContract {
+var FungibleTokenBondingCurveAdmin = class extends import_o1js8.TokenContract {
   constructor() {
     super(...arguments);
-    this.owner = (0, import_o1js7.State)(import_o1js7.PublicKey.empty());
-    this.token = (0, import_o1js7.State)(import_o1js7.PublicKey.empty());
-    this.feeMaster = (0, import_o1js7.State)(import_o1js7.PublicKey.empty());
-    this.curve = (0, import_o1js7.State)();
-    this.insideMint = (0, import_o1js7.State)((0, import_o1js7.Bool)(false));
+    this.owner = (0, import_o1js8.State)(import_o1js8.PublicKey.empty());
+    this.token = (0, import_o1js8.State)(import_o1js8.PublicKey.empty());
+    this.feeMaster = (0, import_o1js8.State)(import_o1js8.PublicKey.empty());
+    this.curve = (0, import_o1js8.State)();
+    this.insideMint = (0, import_o1js8.State)((0, import_o1js8.Bool)(false));
     this.events = {
       mint: BondingMintEvent,
       redeem: BondingRedeemEvent
@@ -1186,16 +1230,16 @@ var FungibleTokenBondingCurveAdmin = class extends import_o1js7.TokenContract {
   async deploy(props) {
     await super.deploy(props);
     this.curve.set(new BondingCurveParams({
-      startPrice: import_o1js7.UInt64.from(1e4),
-      curveK: import_o1js7.UInt64.from(1e4),
-      fee: import_o1js7.UInt32.from(1e3),
-      mintingIsAllowed: (0, import_o1js7.Bool)(false)
+      startPrice: import_o1js8.UInt64.from(1e4),
+      curveK: import_o1js8.UInt64.from(1e4),
+      fee: import_o1js8.UInt32.from(1e3),
+      mintingIsAllowed: (0, import_o1js8.Bool)(false)
     }).pack());
     this.account.permissions.set({
-      ...import_o1js7.Permissions.default(),
-      setVerificationKey: import_o1js7.Permissions.VerificationKey.impossibleDuringCurrentVersion(),
-      setPermissions: import_o1js7.Permissions.impossible(),
-      send: import_o1js7.Permissions.proof()
+      ...import_o1js8.Permissions.default(),
+      setVerificationKey: import_o1js8.Permissions.VerificationKey.impossibleDuringCurrentVersion(),
+      setPermissions: import_o1js8.Permissions.impossible(),
+      send: import_o1js8.Permissions.proof()
     });
   }
   async approveBase(forest) {
@@ -1203,41 +1247,41 @@ var FungibleTokenBondingCurveAdmin = class extends import_o1js7.TokenContract {
   }
   async initialize(props) {
     const { tokenAddress, feeMaster, startPrice, curveK, fee, launchFee, numberOfNewAccounts } = props;
-    this.account.provedState.requireEquals((0, import_o1js7.Bool)(false));
+    this.account.provedState.requireEquals((0, import_o1js8.Bool)(false));
     this.token.set(tokenAddress);
     this.feeMaster.set(feeMaster);
     this.curve.set(new BondingCurveParams({
       startPrice,
       curveK,
       fee,
-      mintingIsAllowed: (0, import_o1js7.Bool)(false)
+      mintingIsAllowed: (0, import_o1js8.Bool)(false)
     }).pack());
-    const supplyUpdate = import_o1js7.AccountUpdate.createSigned(this.address, this.deriveTokenId());
-    let permissions = import_o1js7.Permissions.default();
-    permissions.send = import_o1js7.Permissions.none();
-    permissions.setPermissions = import_o1js7.Permissions.impossible();
+    const supplyUpdate = import_o1js8.AccountUpdate.createSigned(this.address, this.deriveTokenId());
+    let permissions = import_o1js8.Permissions.default();
+    permissions.send = import_o1js8.Permissions.none();
+    permissions.setPermissions = import_o1js8.Permissions.impossible();
     supplyUpdate.account.permissions.set(permissions);
-    const payment = launchFee.add(numberOfNewAccounts.mul(import_o1js7.UInt64.from(1e9)));
+    const payment = launchFee.add(numberOfNewAccounts.mul(import_o1js8.UInt64.from(1e9)));
     const owner = this.sender.getUnconstrained();
-    const ownerUpdate = import_o1js7.AccountUpdate.create(owner);
+    const ownerUpdate = import_o1js8.AccountUpdate.create(owner);
     ownerUpdate.requireSignature();
     this.owner.set(owner);
-    ownerUpdate.body.useFullCommitment = (0, import_o1js7.Bool)(true);
-    ownerUpdate.account.balance.requireBetween(payment, import_o1js7.UInt64.MAXINT());
+    ownerUpdate.body.useFullCommitment = (0, import_o1js8.Bool)(true);
+    ownerUpdate.account.balance.requireBetween(payment, import_o1js8.UInt64.MAXINT());
     ownerUpdate.balance.subInPlace(payment);
-    const feeUpdate = import_o1js7.AccountUpdate.create(feeMaster);
+    const feeUpdate = import_o1js8.AccountUpdate.create(feeMaster);
     feeUpdate.balance.addInPlace(launchFee);
   }
   async mint(to, amount, price) {
-    this.insideMint.getAndRequireEquals().assertEquals((0, import_o1js7.Bool)(false));
-    this.insideMint.set((0, import_o1js7.Bool)(true));
+    this.insideMint.getAndRequireEquals().assertEquals((0, import_o1js8.Bool)(false));
+    this.insideMint.set((0, import_o1js8.Bool)(true));
     const tokenAddress = this.token.getAndRequireEquals();
     const token = new BondingCurveFungibleToken(tokenAddress);
     const { startPrice, curveK, fee, mintingIsAllowed } = BondingCurveParams.unpack(this.curve.getAndRequireEquals());
     const buyer = this.sender.getUnconstrained();
-    const buyerUpdate = import_o1js7.AccountUpdate.create(buyer);
+    const buyerUpdate = import_o1js8.AccountUpdate.create(buyer);
     buyerUpdate.requireSignature();
-    buyerUpdate.body.useFullCommitment = (0, import_o1js7.Bool)(true);
+    buyerUpdate.body.useFullCommitment = (0, import_o1js8.Bool)(true);
     const owner = this.owner.getAndRequireEquals();
     const isOwner = owner.equals(buyer);
     const canMint = isOwner.or(mintingIsAllowed);
@@ -1246,22 +1290,22 @@ var FungibleTokenBondingCurveAdmin = class extends import_o1js7.TokenContract {
       startPrice,
       curveK,
       fee,
-      mintingIsAllowed: (0, import_o1js7.Bool)(true)
+      mintingIsAllowed: (0, import_o1js8.Bool)(true)
     }).pack());
-    const maximumSupplyField = import_o1js7.Provable.witness(import_o1js7.Field, () => {
+    const maximumSupplyField = import_o1js8.Provable.witness(import_o1js8.Field, () => {
       if (price.toBigInt() < startPrice.toBigInt()) {
         throw Error("Price must be greater than or equal to the start price");
       }
-      return import_o1js7.Field.from((price.toBigInt() - startPrice.toBigInt()) * 10n ** 14n / curveK.toBigInt());
+      return import_o1js8.Field.from((price.toBigInt() - startPrice.toBigInt()) * 10n ** 14n / curveK.toBigInt());
     });
-    maximumSupplyField.mul(curveK.value).add(startPrice.value.mul(import_o1js7.Field.from(10 ** 14))).assertLessThanOrEqual(price.value.mul(import_o1js7.Field.from(10 ** 14)));
-    maximumSupplyField.assertLessThan(import_o1js7.UInt64.MAXINT().value);
-    const maximumSupply = import_o1js7.UInt64.Unsafe.fromField(maximumSupplyField);
-    const supplyUpdate = import_o1js7.AccountUpdate.create(this.address, this.deriveTokenId());
-    supplyUpdate.account.balance.requireBetween(import_o1js7.UInt64.zero, maximumSupply);
-    amount.assertLessThanOrEqual(import_o1js7.UInt64.from(2n ** 62n));
-    supplyUpdate.balanceChange = import_o1js7.Int64.fromUnsigned(amount);
-    const paymentField = import_o1js7.Provable.witness(import_o1js7.Field, () => {
+    maximumSupplyField.mul(curveK.value).add(startPrice.value.mul(import_o1js8.Field.from(10 ** 14))).assertLessThanOrEqual(price.value.mul(import_o1js8.Field.from(10 ** 14)));
+    maximumSupplyField.assertLessThan(import_o1js8.UInt64.MAXINT().value);
+    const maximumSupply = import_o1js8.UInt64.Unsafe.fromField(maximumSupplyField);
+    const supplyUpdate = import_o1js8.AccountUpdate.create(this.address, this.deriveTokenId());
+    supplyUpdate.account.balance.requireBetween(import_o1js8.UInt64.zero, maximumSupply);
+    amount.assertLessThanOrEqual(import_o1js8.UInt64.from(2n ** 62n));
+    supplyUpdate.balanceChange = import_o1js8.Int64.fromUnsigned(amount);
+    const paymentField = import_o1js8.Provable.witness(import_o1js8.Field, () => {
       let payment2 = price.toBigInt() * amount.toBigInt() / 10n ** 9n;
       if (payment2 * 10n ** 9n !== price.toBigInt() * amount.toBigInt()) {
         payment2++;
@@ -1269,12 +1313,12 @@ var FungibleTokenBondingCurveAdmin = class extends import_o1js7.TokenContract {
       if (payment2 * 10n ** 9n < price.toBigInt() * amount.toBigInt()) {
         throw Error("Payment calculation failed");
       }
-      return import_o1js7.Field.from(payment2);
+      return import_o1js8.Field.from(payment2);
     });
-    paymentField.mul(import_o1js7.Field.from(10 ** 9)).assertGreaterThanOrEqual(price.value.mul(amount.value));
-    paymentField.assertLessThan(import_o1js7.UInt64.MAXINT().value);
-    const payment = import_o1js7.UInt64.Unsafe.fromField(paymentField);
-    const feePaymentField = import_o1js7.Provable.witness(import_o1js7.Field, () => {
+    paymentField.mul(import_o1js8.Field.from(10 ** 9)).assertGreaterThanOrEqual(price.value.mul(amount.value));
+    paymentField.assertLessThan(import_o1js8.UInt64.MAXINT().value);
+    const payment = import_o1js8.UInt64.Unsafe.fromField(paymentField);
+    const feePaymentField = import_o1js8.Provable.witness(import_o1js8.Field, () => {
       let feePayment2 = payment.toBigInt() * fee.toBigint() / 100000n;
       if (feePayment2 * 100000n !== payment.toBigInt() * fee.toBigint()) {
         feePayment2++;
@@ -1282,20 +1326,20 @@ var FungibleTokenBondingCurveAdmin = class extends import_o1js7.TokenContract {
       if (feePayment2 * 100000n < payment.toBigInt() * fee.toBigint()) {
         throw Error("Fee calculation failed");
       }
-      return import_o1js7.Field.from(feePayment2);
+      return import_o1js8.Field.from(feePayment2);
     });
-    feePaymentField.mul(import_o1js7.Field.from(1e5)).assertGreaterThanOrEqual(payment.value.mul(fee.value));
-    feePaymentField.assertLessThan(import_o1js7.UInt64.MAXINT().value);
-    let feePayment = import_o1js7.UInt64.Unsafe.fromField(feePaymentField);
-    feePayment = import_o1js7.Provable.if(feePayment.lessThan(import_o1js7.UInt64.from(1e8)), import_o1js7.UInt64.from(1e8), feePayment);
+    feePaymentField.mul(import_o1js8.Field.from(1e5)).assertGreaterThanOrEqual(payment.value.mul(fee.value));
+    feePaymentField.assertLessThan(import_o1js8.UInt64.MAXINT().value);
+    let feePayment = import_o1js8.UInt64.Unsafe.fromField(feePaymentField);
+    feePayment = import_o1js8.Provable.if(feePayment.lessThan(import_o1js8.UInt64.from(1e8)), import_o1js8.UInt64.from(1e8), feePayment);
     const tokenUpdate = await token.mint(to, amount);
     const isNew = tokenUpdate.account.isNew.get();
-    const totalPayment = payment.add(feePayment).add(import_o1js7.Provable.if(isNew, import_o1js7.UInt64.from(1e9), import_o1js7.UInt64.zero));
-    buyerUpdate.account.balance.requireBetween(totalPayment, import_o1js7.UInt64.MAXINT());
+    const totalPayment = payment.add(feePayment).add(import_o1js8.Provable.if(isNew, import_o1js8.UInt64.from(1e9), import_o1js8.UInt64.zero));
+    buyerUpdate.account.balance.requireBetween(totalPayment, import_o1js8.UInt64.MAXINT());
     buyerUpdate.balance.subInPlace(totalPayment);
     this.balance.addInPlace(payment);
-    const feeUpdate = import_o1js7.AccountUpdate.create(this.feeMaster.getAndRequireEquals());
-    feeUpdate.body.useFullCommitment = (0, import_o1js7.Bool)(true);
+    const feeUpdate = import_o1js8.AccountUpdate.create(this.feeMaster.getAndRequireEquals());
+    feeUpdate.body.useFullCommitment = (0, import_o1js8.Bool)(true);
     feeUpdate.balance.addInPlace(feePayment);
     this.emitEvent("mint", new BondingMintEvent({
       to,
@@ -1313,17 +1357,17 @@ var FungibleTokenBondingCurveAdmin = class extends import_o1js7.TokenContract {
   async redeem(amount, minPrice, slippage) {
     const tokenAddress = this.token.getAndRequireEquals();
     const token = new BondingCurveFungibleToken(tokenAddress);
-    const balance = await import_o1js7.Provable.witnessAsync(import_o1js7.UInt64, async () => {
-      await (0, import_o1js7.fetchAccount)({
+    const balance = await import_o1js8.Provable.witnessAsync(import_o1js8.UInt64, async () => {
+      await (0, import_o1js8.fetchAccount)({
         publicKey: this.address,
         tokenId: this.tokenId
       });
-      const balance2 = import_o1js7.Mina.getAccount(this.address, this.tokenId).balance;
+      const balance2 = import_o1js8.Mina.getAccount(this.address, this.tokenId).balance;
       console.log("redeem: balance", balance2.toBigInt());
       return balance2;
     });
-    slippage.assertLessThan(import_o1js7.UInt32.from(1e3));
-    const minBalanceField = import_o1js7.Provable.witness(import_o1js7.Field, () => {
+    slippage.assertLessThan(import_o1js8.UInt32.from(1e3));
+    const minBalanceField = import_o1js8.Provable.witness(import_o1js8.Field, () => {
       let minBalance2 = balance.toBigInt() * (1000n - slippage.toBigint()) / 1000n;
       if (minBalance2 * 1000n !== balance.toBigInt() * (1000n - slippage.toBigint())) {
         minBalance2++;
@@ -1331,38 +1375,38 @@ var FungibleTokenBondingCurveAdmin = class extends import_o1js7.TokenContract {
       if (minBalance2 * 1000n < balance.toBigInt() * (1000n - slippage.toBigint())) {
         throw Error("Min balance calculation failed");
       }
-      return import_o1js7.Field.from(minBalance2);
+      return import_o1js8.Field.from(minBalance2);
     });
-    minBalanceField.mul(import_o1js7.Field.from(1e3)).add(balance.value.mul(slippage.value)).assertGreaterThanOrEqual(balance.value.mul(import_o1js7.Field.from(1e3)));
-    minBalanceField.assertLessThan(import_o1js7.UInt64.MAXINT().value);
-    const minBalance = import_o1js7.UInt64.Unsafe.fromField(minBalanceField);
-    this.account.balance.requireBetween(minBalance, import_o1js7.UInt64.MAXINT());
-    const supply = await import_o1js7.Provable.witnessAsync(import_o1js7.UInt64, async () => {
-      await (0, import_o1js7.fetchAccount)({
+    minBalanceField.mul(import_o1js8.Field.from(1e3)).add(balance.value.mul(slippage.value)).assertGreaterThanOrEqual(balance.value.mul(import_o1js8.Field.from(1e3)));
+    minBalanceField.assertLessThan(import_o1js8.UInt64.MAXINT().value);
+    const minBalance = import_o1js8.UInt64.Unsafe.fromField(minBalanceField);
+    this.account.balance.requireBetween(minBalance, import_o1js8.UInt64.MAXINT());
+    const supply = await import_o1js8.Provable.witnessAsync(import_o1js8.UInt64, async () => {
+      await (0, import_o1js8.fetchAccount)({
         publicKey: this.address,
         tokenId: this.deriveTokenId()
       });
-      const balance2 = import_o1js7.Mina.getAccount(this.address, this.deriveTokenId()).balance;
+      const balance2 = import_o1js8.Mina.getAccount(this.address, this.deriveTokenId()).balance;
       console.log("redeem: supply", balance2.toBigInt());
       return balance2;
     });
     supply.assertGreaterThanOrEqual(amount);
-    supply.assertGreaterThan(import_o1js7.UInt64.zero);
-    const maxSupplyField = import_o1js7.Provable.witness(import_o1js7.Field, () => import_o1js7.Field.from(supply.toBigInt() * (1000n + slippage.toBigint()) / 1000n));
-    maxSupplyField.mul(import_o1js7.Field.from(1e3)).assertLessThanOrEqual(supply.value.mul(import_o1js7.Field.from(1e3).add(slippage.value)));
-    maxSupplyField.assertLessThan(import_o1js7.UInt64.MAXINT().value);
-    const maxSupply = import_o1js7.UInt64.Unsafe.fromField(maxSupplyField);
-    const supplyUpdate = import_o1js7.AccountUpdate.create(this.address, this.deriveTokenId());
-    supplyUpdate.account.balance.requireBetween(import_o1js7.UInt64.zero, maxSupply);
-    supplyUpdate.balanceChange = import_o1js7.Int64.fromUnsigned(amount).neg();
-    const paymentField = import_o1js7.Provable.witness(import_o1js7.Field, () => import_o1js7.Field.from(minBalance.toBigInt() * amount.toBigInt() / maxSupply.toBigInt()));
+    supply.assertGreaterThan(import_o1js8.UInt64.zero);
+    const maxSupplyField = import_o1js8.Provable.witness(import_o1js8.Field, () => import_o1js8.Field.from(supply.toBigInt() * (1000n + slippage.toBigint()) / 1000n));
+    maxSupplyField.mul(import_o1js8.Field.from(1e3)).assertLessThanOrEqual(supply.value.mul(import_o1js8.Field.from(1e3).add(slippage.value)));
+    maxSupplyField.assertLessThan(import_o1js8.UInt64.MAXINT().value);
+    const maxSupply = import_o1js8.UInt64.Unsafe.fromField(maxSupplyField);
+    const supplyUpdate = import_o1js8.AccountUpdate.create(this.address, this.deriveTokenId());
+    supplyUpdate.account.balance.requireBetween(import_o1js8.UInt64.zero, maxSupply);
+    supplyUpdate.balanceChange = import_o1js8.Int64.fromUnsigned(amount).neg();
+    const paymentField = import_o1js8.Provable.witness(import_o1js8.Field, () => import_o1js8.Field.from(minBalance.toBigInt() * amount.toBigInt() / maxSupply.toBigInt()));
     paymentField.mul(maxSupply.value).assertLessThanOrEqual(minBalance.value.mul(amount.value));
-    paymentField.assertLessThan(import_o1js7.Field.from(2n ** 62n));
-    amount.value.mul(minPrice.value).assertLessThanOrEqual(paymentField.mul(import_o1js7.Field.from(10 ** 9)));
-    const payment = import_o1js7.UInt64.Unsafe.fromField(paymentField);
+    paymentField.assertLessThan(import_o1js8.Field.from(2n ** 62n));
+    amount.value.mul(minPrice.value).assertLessThanOrEqual(paymentField.mul(import_o1js8.Field.from(10 ** 9)));
+    const payment = import_o1js8.UInt64.Unsafe.fromField(paymentField);
     const { fee, mintingIsAllowed } = BondingCurveParams.unpack(this.curve.getAndRequireEquals());
     mintingIsAllowed.assertTrue("Minting is disabled for this token, nothing to redeem");
-    let feePayment = import_o1js7.Provable.witness(import_o1js7.UInt64, () => {
+    let feePayment = import_o1js8.Provable.witness(import_o1js8.UInt64, () => {
       let feePayment2 = payment.toBigInt() * fee.toBigint() / 100000n;
       if (feePayment2 * 100000n !== payment.toBigInt() * fee.toBigint()) {
         feePayment2++;
@@ -1370,23 +1414,23 @@ var FungibleTokenBondingCurveAdmin = class extends import_o1js7.TokenContract {
       if (feePayment2 * 100000n < payment.toBigInt() * fee.toBigint()) {
         throw Error("Fee calculation failed");
       }
-      return import_o1js7.UInt64.from(feePayment2);
+      return import_o1js8.UInt64.from(feePayment2);
     });
-    feePayment = import_o1js7.Provable.if(feePayment.lessThan(import_o1js7.UInt64.from(1e8)), import_o1js7.UInt64.from(1e8), feePayment);
+    feePayment = import_o1js8.Provable.if(feePayment.lessThan(import_o1js8.UInt64.from(1e8)), import_o1js8.UInt64.from(1e8), feePayment);
     const seller = this.sender.getUnconstrained();
-    const sellerUpdate = import_o1js7.AccountUpdate.create(seller);
-    const isNew = await import_o1js7.Provable.witnessAsync(import_o1js7.Bool, async () => {
-      const sellerAccount = await (0, import_o1js7.fetchAccount)({
+    const sellerUpdate = import_o1js8.AccountUpdate.create(seller);
+    const isNew = await import_o1js8.Provable.witnessAsync(import_o1js8.Bool, async () => {
+      const sellerAccount = await (0, import_o1js8.fetchAccount)({
         publicKey: seller
       });
-      return (0, import_o1js7.Bool)(sellerAccount.account === void 0);
+      return (0, import_o1js8.Bool)(sellerAccount.account === void 0);
     });
     sellerUpdate.account.isNew.requireEquals(isNew);
-    const accountCreationFee = import_o1js7.Provable.if(isNew, import_o1js7.UInt64.from(1e9), import_o1js7.UInt64.zero);
+    const accountCreationFee = import_o1js8.Provable.if(isNew, import_o1js8.UInt64.from(1e9), import_o1js8.UInt64.zero);
     payment.assertGreaterThan(feePayment.add(accountCreationFee));
     sellerUpdate.requireSignature();
-    sellerUpdate.body.useFullCommitment = (0, import_o1js7.Bool)(true);
-    const totalPayment = import_o1js7.Provable.witness(import_o1js7.UInt64, () => {
+    sellerUpdate.body.useFullCommitment = (0, import_o1js8.Bool)(true);
+    const totalPayment = import_o1js8.Provable.witness(import_o1js8.UInt64, () => {
       if (payment.toBigInt() < feePayment.toBigInt() + accountCreationFee.toBigInt()) {
         console.error(`The redeem amount ${Number(payment.toBigInt() / 10n ** 6n) / 1e3} MINA is too low to cover the fee ${Number(feePayment.toBigInt() / 10n ** 6n) / 1e3} MINA and account creation fee ${Number(accountCreationFee.toBigInt() / 10n ** 6n) / 1e3} MINA for the account ${seller.toBase58()}`, {
           payment: payment.toBigInt(),
@@ -1403,12 +1447,12 @@ var FungibleTokenBondingCurveAdmin = class extends import_o1js7.TokenContract {
         });
         throw Error(`The redeem amount ${Number(payment.toBigInt() / 10n ** 6n) / 1e3} MINA is too low to cover the fee ${Number(feePayment.toBigInt() / 10n ** 6n) / 1e3} MINA and account creation fee ${Number(accountCreationFee.toBigInt() / 10n ** 6n) / 1e3} MINA for the account ${seller.toBase58()}`);
       }
-      return import_o1js7.UInt64.from(payment.toBigInt() - feePayment.toBigInt() - accountCreationFee.toBigInt());
+      return import_o1js8.UInt64.from(payment.toBigInt() - feePayment.toBigInt() - accountCreationFee.toBigInt());
     });
     totalPayment.add(feePayment).add(accountCreationFee).assertEquals(payment);
     sellerUpdate.balance.addInPlace(totalPayment);
-    const feeUpdate = import_o1js7.AccountUpdate.create(this.feeMaster.getAndRequireEquals());
-    feeUpdate.body.useFullCommitment = (0, import_o1js7.Bool)(true);
+    const feeUpdate = import_o1js8.AccountUpdate.create(this.feeMaster.getAndRequireEquals());
+    feeUpdate.body.useFullCommitment = (0, import_o1js8.Bool)(true);
     feeUpdate.balance.addInPlace(feePayment);
     this.balance.subInPlace(payment);
     await token.burn(seller, amount);
@@ -1428,10 +1472,10 @@ var FungibleTokenBondingCurveAdmin = class extends import_o1js7.TokenContract {
   async sync() {
     const tokenAddress = this.token.getAndRequireEquals();
     const token = new BondingCurveFungibleToken(tokenAddress);
-    const supplyUpdate = import_o1js7.AccountUpdate.create(this.address, this.deriveTokenId());
+    const supplyUpdate = import_o1js8.AccountUpdate.create(this.address, this.deriveTokenId());
     const circulatingSupply = await token.getBalanceOf(tokenAddress);
     const totalSupply = supplyUpdate.account.balance.getAndRequireEquals();
-    supplyUpdate.balanceChange = import_o1js7.Int64.fromUnsigned(totalSupply.sub(circulatingSupply)).neg();
+    supplyUpdate.balanceChange = import_o1js8.Int64.fromUnsigned(totalSupply.sub(circulatingSupply)).neg();
   }
   /** Update the verification key.
    * Note that because we have set the permissions for setting the verification key to `impossibleDuringCurrentVersion()`, this will only be possible in case of a protocol update that requires an update.
@@ -1441,110 +1485,110 @@ var FungibleTokenBondingCurveAdmin = class extends import_o1js7.TokenContract {
   }
   ensureOwnerSignature() {
     const owner = this.owner.getAndRequireEquals();
-    const update = import_o1js7.AccountUpdate.createSigned(owner);
-    update.body.useFullCommitment = (0, import_o1js7.Bool)(true);
+    const update = import_o1js8.AccountUpdate.createSigned(owner);
+    update.body.useFullCommitment = (0, import_o1js8.Bool)(true);
     return update;
   }
   async canMint(_accountUpdate) {
-    this.insideMint.requireEquals((0, import_o1js7.Bool)(true));
-    this.insideMint.set((0, import_o1js7.Bool)(false));
-    return (0, import_o1js7.Bool)(true);
+    this.insideMint.requireEquals((0, import_o1js8.Bool)(true));
+    this.insideMint.set((0, import_o1js8.Bool)(false));
+    return (0, import_o1js8.Bool)(true);
   }
   async canChangeAdmin(_admin) {
     this.ensureOwnerSignature();
-    return (0, import_o1js7.Bool)(true);
+    return (0, import_o1js8.Bool)(true);
   }
   async canPause() {
     this.ensureOwnerSignature();
-    return (0, import_o1js7.Bool)(true);
+    return (0, import_o1js8.Bool)(true);
   }
   async canResume() {
     this.ensureOwnerSignature();
-    return (0, import_o1js7.Bool)(true);
+    return (0, import_o1js8.Bool)(true);
   }
   async canChangeVerificationKey(_vk) {
     this.ensureOwnerSignature();
-    return (0, import_o1js7.Bool)(true);
+    return (0, import_o1js8.Bool)(true);
   }
 };
 (0, import_tslib7.__decorate)([
-  (0, import_o1js7.state)(import_o1js7.PublicKey),
+  (0, import_o1js8.state)(import_o1js8.PublicKey),
   (0, import_tslib7.__metadata)("design:type", Object)
 ], FungibleTokenBondingCurveAdmin.prototype, "owner", void 0);
 (0, import_tslib7.__decorate)([
-  (0, import_o1js7.state)(import_o1js7.PublicKey),
+  (0, import_o1js8.state)(import_o1js8.PublicKey),
   (0, import_tslib7.__metadata)("design:type", Object)
 ], FungibleTokenBondingCurveAdmin.prototype, "token", void 0);
 (0, import_tslib7.__decorate)([
-  (0, import_o1js7.state)(import_o1js7.PublicKey),
+  (0, import_o1js8.state)(import_o1js8.PublicKey),
   (0, import_tslib7.__metadata)("design:type", Object)
 ], FungibleTokenBondingCurveAdmin.prototype, "feeMaster", void 0);
 (0, import_tslib7.__decorate)([
-  (0, import_o1js7.state)(import_o1js7.Field),
+  (0, import_o1js8.state)(import_o1js8.Field),
   (0, import_tslib7.__metadata)("design:type", Object)
 ], FungibleTokenBondingCurveAdmin.prototype, "curve", void 0);
 (0, import_tslib7.__decorate)([
-  (0, import_o1js7.state)(import_o1js7.Bool),
+  (0, import_o1js8.state)(import_o1js8.Bool),
   (0, import_tslib7.__metadata)("design:type", Object)
 ], FungibleTokenBondingCurveAdmin.prototype, "insideMint", void 0);
 (0, import_tslib7.__decorate)([
-  import_o1js7.method,
+  import_o1js8.method,
   (0, import_tslib7.__metadata)("design:type", Function),
   (0, import_tslib7.__metadata)("design:paramtypes", [BondingCurveAdminInitializeProps]),
   (0, import_tslib7.__metadata)("design:returntype", Promise)
 ], FungibleTokenBondingCurveAdmin.prototype, "initialize", null);
 (0, import_tslib7.__decorate)([
-  import_o1js7.method,
+  import_o1js8.method,
   (0, import_tslib7.__metadata)("design:type", Function),
-  (0, import_tslib7.__metadata)("design:paramtypes", [import_o1js7.PublicKey, import_o1js7.UInt64, import_o1js7.UInt64]),
+  (0, import_tslib7.__metadata)("design:paramtypes", [import_o1js8.PublicKey, import_o1js8.UInt64, import_o1js8.UInt64]),
   (0, import_tslib7.__metadata)("design:returntype", Promise)
 ], FungibleTokenBondingCurveAdmin.prototype, "mint", null);
 (0, import_tslib7.__decorate)([
-  import_o1js7.method,
+  import_o1js8.method,
   (0, import_tslib7.__metadata)("design:type", Function),
-  (0, import_tslib7.__metadata)("design:paramtypes", [import_o1js7.UInt64, import_o1js7.UInt64, import_o1js7.UInt32]),
+  (0, import_tslib7.__metadata)("design:paramtypes", [import_o1js8.UInt64, import_o1js8.UInt64, import_o1js8.UInt32]),
   (0, import_tslib7.__metadata)("design:returntype", Promise)
 ], FungibleTokenBondingCurveAdmin.prototype, "redeem", null);
 (0, import_tslib7.__decorate)([
-  import_o1js7.method,
+  import_o1js8.method,
   (0, import_tslib7.__metadata)("design:type", Function),
   (0, import_tslib7.__metadata)("design:paramtypes", []),
   (0, import_tslib7.__metadata)("design:returntype", Promise)
 ], FungibleTokenBondingCurveAdmin.prototype, "sync", null);
 (0, import_tslib7.__decorate)([
-  import_o1js7.method,
+  import_o1js8.method,
   (0, import_tslib7.__metadata)("design:type", Function),
-  (0, import_tslib7.__metadata)("design:paramtypes", [import_o1js7.VerificationKey]),
+  (0, import_tslib7.__metadata)("design:paramtypes", [import_o1js8.VerificationKey]),
   (0, import_tslib7.__metadata)("design:returntype", Promise)
 ], FungibleTokenBondingCurveAdmin.prototype, "updateVerificationKey", null);
 (0, import_tslib7.__decorate)([
-  import_o1js7.method.returns(import_o1js7.Bool),
+  import_o1js8.method.returns(import_o1js8.Bool),
   (0, import_tslib7.__metadata)("design:type", Function),
-  (0, import_tslib7.__metadata)("design:paramtypes", [import_o1js7.AccountUpdate]),
+  (0, import_tslib7.__metadata)("design:paramtypes", [import_o1js8.AccountUpdate]),
   (0, import_tslib7.__metadata)("design:returntype", Promise)
 ], FungibleTokenBondingCurveAdmin.prototype, "canMint", null);
 (0, import_tslib7.__decorate)([
-  import_o1js7.method.returns(import_o1js7.Bool),
+  import_o1js8.method.returns(import_o1js8.Bool),
   (0, import_tslib7.__metadata)("design:type", Function),
-  (0, import_tslib7.__metadata)("design:paramtypes", [import_o1js7.PublicKey]),
+  (0, import_tslib7.__metadata)("design:paramtypes", [import_o1js8.PublicKey]),
   (0, import_tslib7.__metadata)("design:returntype", Promise)
 ], FungibleTokenBondingCurveAdmin.prototype, "canChangeAdmin", null);
 (0, import_tslib7.__decorate)([
-  import_o1js7.method.returns(import_o1js7.Bool),
+  import_o1js8.method.returns(import_o1js8.Bool),
   (0, import_tslib7.__metadata)("design:type", Function),
   (0, import_tslib7.__metadata)("design:paramtypes", []),
   (0, import_tslib7.__metadata)("design:returntype", Promise)
 ], FungibleTokenBondingCurveAdmin.prototype, "canPause", null);
 (0, import_tslib7.__decorate)([
-  import_o1js7.method.returns(import_o1js7.Bool),
+  import_o1js8.method.returns(import_o1js8.Bool),
   (0, import_tslib7.__metadata)("design:type", Function),
   (0, import_tslib7.__metadata)("design:paramtypes", []),
   (0, import_tslib7.__metadata)("design:returntype", Promise)
 ], FungibleTokenBondingCurveAdmin.prototype, "canResume", null);
 (0, import_tslib7.__decorate)([
-  import_o1js7.method.returns(import_o1js7.Bool),
+  import_o1js8.method.returns(import_o1js8.Bool),
   (0, import_tslib7.__metadata)("design:type", Function),
-  (0, import_tslib7.__metadata)("design:paramtypes", [import_o1js7.VerificationKey]),
+  (0, import_tslib7.__metadata)("design:paramtypes", [import_o1js8.VerificationKey]),
   (0, import_tslib7.__metadata)("design:returntype", Promise)
 ], FungibleTokenBondingCurveAdmin.prototype, "canChangeVerificationKey", null);
 var BondingCurveFungibleToken = (0, import_token.FungibleTokenContract)(FungibleTokenBondingCurveAdmin);