@stellar/stellar-base 14.0.4 → 14.1.0

package/lib/auth.js

@@ -26,10 +26,8 @@ function _asyncToGenerator(n) { return function () { var t = this, e = arguments
  *    whose hash you should sign, so that you can inspect the entire structure
  *    if necessary (rather than blindly signing a hash)
  *
- * @returns {
- *    Promise<Uint8Array> |
- *    Promise<{signature: Uint8Array, publicKey: string}
- * }  the signature of the raw payload (which is the sha256 hash of the preimage
+ * @returns {Promise<Uint8Array | {signature: Uint8Array, publicKey: string}>}
+ *    the signature of the raw payload (which is the sha256 hash of the preimage
  *    bytes, so `hash(preimage.toXDR())`) either naked, implying it is signed
  *    by the key corresponding to the public key in the entry you pass to
  *    {@link authorizeEntry} (decipherable from its

package/lib/transaction_builder.js

@@ -17,6 +17,11 @@ var _sorobandata_builder = require("./sorobandata_builder");
 var _strkey = require("./strkey");
 var _signerkey = require("./signerkey");
 var _memo = require("./memo");
+var _asset = require("./asset");
+var _scval = require("./scval");
+var _operation = require("./operation");
+var _address = require("./address");
+var _keypair = require("./keypair");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
 function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
 function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
@@ -32,7 +37,7 @@ function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Can
 function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
 function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } // eslint-disable-next-line no-unused-vars
 /**
  * Minimum base fee for transactions. If this fee is below the network
  * minimum, the transaction will fail. The more operations in the
@@ -52,6 +57,14 @@ var BASE_FEE = exports.BASE_FEE = '100'; // Stroops
  */
 var TimeoutInfinite = exports.TimeoutInfinite = 0;
 
+/**
+ * @typedef {object} SorobanFees
+ * @property {number} instructions - the number of instructions executed by the transaction
+ * @property {number} readBytes - the number of bytes read from the ledger by the transaction
+ * @property {number} writeBytes - the number of bytes written to the ledger by the transaction
+ * @property {bigint} resourceFee - the fee to be paid for the transaction, in stroops
+ */
+
 /**
  * <p>Transaction builder helps constructs a new `{@link Transaction}` using the
  * given {@link Account} as the transaction's "source account". The transaction
@@ -554,6 +567,150 @@ var TransactionBuilder = exports.TransactionBuilder = /*#__PURE__*/function () {
       return this;
     }
 
+    /**
+     * Creates and adds an invoke host function operation for transferring SAC tokens.
+     * This method removes the need for simulation by handling the creation of the
+     * appropriate authorization entries and ledger footprint for the transfer operation.
+     *
+     * @param {string} destination - the address of the recipient of the SAC transfer (should be a valid Stellar address or contract ID)
+     * @param {Asset} asset - the SAC asset to be transferred
+     * @param  {BigInt} amount - the amount of tokens to be transferred in 7 decimals. IE 1 token with 7 decimals of precision would be represented as "1_0000000"
+     * @param {SorobanFees} [sorobanFees] - optional Soroban fees for the transaction to override the default fees used
+     *
+     * @returns {TransactionBuilder}
+     */
+  }, {
+    key: "addSacTransferOperation",
+    value: function addSacTransferOperation(destination, asset, amount, sorobanFees) {
+      if (BigInt(amount) <= 0n) {
+        throw new Error('Amount must be a positive integer');
+      } else if (BigInt(amount) > _jsXdr.Hyper.MAX_VALUE) {
+        // The largest supported value for SAC is i64 however the contract interface uses i128 which is why we convert it to i128
+        throw new Error('Amount exceeds maximum value for i64');
+      }
+      if (sorobanFees) {
+        var instructions = sorobanFees.instructions,
+          readBytes = sorobanFees.readBytes,
+          writeBytes = sorobanFees.writeBytes,
+          resourceFee = sorobanFees.resourceFee;
+        var U32_MAX = 4294967295;
+        if (instructions <= 0 || instructions > U32_MAX) {
+          throw new Error("instructions must be greater than 0 and at most ".concat(U32_MAX));
+        }
+        if (readBytes <= 0 || readBytes > U32_MAX) {
+          throw new Error("readBytes must be greater than 0 and at most ".concat(U32_MAX));
+        }
+        if (writeBytes <= 0 || writeBytes > U32_MAX) {
+          throw new Error("writeBytes must be greater than 0 and at most ".concat(U32_MAX));
+        }
+        if (resourceFee <= 0n || resourceFee > _jsXdr.Hyper.MAX_VALUE) {
+          throw new Error('resourceFee must be greater than 0 and at most i64 max');
+        }
+      }
+      var isDestinationContract = _strkey.StrKey.isValidContract(destination);
+      if (!isDestinationContract) {
+        if (!_strkey.StrKey.isValidEd25519PublicKey(destination) && !_strkey.StrKey.isValidMed25519PublicKey(destination)) {
+          throw new Error('Invalid destination address. Must be a valid Stellar address or contract ID.');
+        }
+      }
+      if (destination === this.source.accountId()) {
+        throw new Error('Destination cannot be the same as the source account.');
+      }
+      var contractId = asset.contractId(this.networkPassphrase);
+      var functionName = 'transfer';
+      var source = this.source.accountId();
+      var args = [(0, _scval.nativeToScVal)(source, {
+        type: 'address'
+      }), (0, _scval.nativeToScVal)(destination, {
+        type: 'address'
+      }), (0, _scval.nativeToScVal)(amount, {
+        type: 'i128'
+      })];
+      var isAssetNative = asset.isNative();
+      var auths = new _xdr["default"].SorobanAuthorizationEntry({
+        credentials: _xdr["default"].SorobanCredentials.sorobanCredentialsSourceAccount(),
+        rootInvocation: new _xdr["default"].SorobanAuthorizedInvocation({
+          "function": _xdr["default"].SorobanAuthorizedFunction.sorobanAuthorizedFunctionTypeContractFn(new _xdr["default"].InvokeContractArgs({
+            contractAddress: _address.Address.fromString(contractId).toScAddress(),
+            functionName: functionName,
+            args: args
+          })),
+          subInvocations: []
+        })
+      });
+      var footprint = new _xdr["default"].LedgerFootprint({
+        readOnly: [_xdr["default"].LedgerKey.contractData(new _xdr["default"].LedgerKeyContractData({
+          contract: _address.Address.fromString(contractId).toScAddress(),
+          key: _xdr["default"].ScVal.scvLedgerKeyContractInstance(),
+          durability: _xdr["default"].ContractDataDurability.persistent()
+        }))],
+        readWrite: []
+      });
+
+      // Ledger entries for the destination account
+      if (isDestinationContract) {
+        footprint.readWrite().push(_xdr["default"].LedgerKey.contractData(new _xdr["default"].LedgerKeyContractData({
+          contract: _address.Address.fromString(contractId).toScAddress(),
+          key: _xdr["default"].ScVal.scvVec([(0, _scval.nativeToScVal)('Balance', {
+            type: 'symbol'
+          }), (0, _scval.nativeToScVal)(destination, {
+            type: 'address'
+          })]),
+          durability: _xdr["default"].ContractDataDurability.persistent()
+        })));
+        if (!isAssetNative) {
+          footprint.readOnly().push(_xdr["default"].LedgerKey.account(new _xdr["default"].LedgerKeyAccount({
+            accountId: _keypair.Keypair.fromPublicKey(asset.getIssuer()).xdrPublicKey()
+          })));
+        }
+      } else if (isAssetNative) {
+        footprint.readWrite().push(_xdr["default"].LedgerKey.account(new _xdr["default"].LedgerKeyAccount({
+          accountId: _keypair.Keypair.fromPublicKey(destination).xdrPublicKey()
+        })));
+      } else if (asset.getIssuer() !== destination) {
+        footprint.readWrite().push(_xdr["default"].LedgerKey.trustline(new _xdr["default"].LedgerKeyTrustLine({
+          accountId: _keypair.Keypair.fromPublicKey(destination).xdrPublicKey(),
+          asset: asset.toTrustLineXDRObject()
+        })));
+      }
+
+      // Ledger entries for the source account
+      if (asset.isNative()) {
+        footprint.readWrite().push(_xdr["default"].LedgerKey.account(new _xdr["default"].LedgerKeyAccount({
+          accountId: _keypair.Keypair.fromPublicKey(source).xdrPublicKey()
+        })));
+      } else if (asset.getIssuer() !== source) {
+        footprint.readWrite().push(_xdr["default"].LedgerKey.trustline(new _xdr["default"].LedgerKeyTrustLine({
+          accountId: _keypair.Keypair.fromPublicKey(source).xdrPublicKey(),
+          asset: asset.toTrustLineXDRObject()
+        })));
+      }
+      var defaultPaymentFees = {
+        instructions: 400000,
+        readBytes: 1000,
+        writeBytes: 1000,
+        resourceFee: BigInt(5000000)
+      };
+      var sorobanData = new _xdr["default"].SorobanTransactionData({
+        resources: new _xdr["default"].SorobanResources({
+          footprint: footprint,
+          instructions: sorobanFees ? sorobanFees.instructions : defaultPaymentFees.instructions,
+          diskReadBytes: sorobanFees ? sorobanFees.readBytes : defaultPaymentFees.readBytes,
+          writeBytes: sorobanFees ? sorobanFees.writeBytes : defaultPaymentFees.writeBytes
+        }),
+        ext: new _xdr["default"].SorobanTransactionDataExt(0),
+        resourceFee: new _xdr["default"].Int64(sorobanFees ? sorobanFees.resourceFee : defaultPaymentFees.resourceFee)
+      });
+      var operation = _operation.Operation.invokeContractFunction({
+        contract: contractId,
+        "function": functionName,
+        args: args,
+        auth: [auths]
+      });
+      this.setSorobanData(sorobanData);
+      return this.addOperation(operation);
+    }
+
     /**
      * This will build the transaction.
      * It will also increment the source account's sequence number by 1.
@@ -610,6 +767,8 @@ var TransactionBuilder = exports.TransactionBuilder = /*#__PURE__*/function () {
       if (this.sorobanData) {
         // @ts-ignore
         attrs.ext = new _xdr["default"].TransactionExt(1, this.sorobanData);
+        // Soroban transactions pay the resource fee in addition to the regular fee, so we need to add it here.
+        attrs.fee = new _bignumber["default"](attrs.fee).plus(this.sorobanData.resourceFee()).toNumber();
       } else {
         // @ts-ignore
         attrs.ext = new _xdr["default"].TransactionExt(0, _xdr["default"].Void);
@@ -695,7 +854,6 @@ var TransactionBuilder = exports.TransactionBuilder = /*#__PURE__*/function () {
     value: function buildFeeBumpTransaction(feeSource, baseFee, innerTx, networkPassphrase) {
       var innerOps = innerTx.operations.length;
       var minBaseFee = new _bignumber["default"](BASE_FEE);
-      var innerInclusionFee = new _bignumber["default"](innerTx.fee).div(innerOps);
       var resourceFee = new _bignumber["default"](0);
 
       // Do we need to do special Soroban fee handling? We only want the fee-bump
@@ -707,12 +865,12 @@ var TransactionBuilder = exports.TransactionBuilder = /*#__PURE__*/function () {
             var _sorobanData$resource;
             var sorobanData = env.v1().tx().ext().value();
             resourceFee = new _bignumber["default"]((_sorobanData$resource = sorobanData === null || sorobanData === void 0 ? void 0 : sorobanData.resourceFee()) !== null && _sorobanData$resource !== void 0 ? _sorobanData$resource : 0);
-            innerInclusionFee = _bignumber["default"].max(minBaseFee, innerInclusionFee.minus(resourceFee));
             break;
           }
         default:
           break;
       }
+      var innerInclusionFee = new _bignumber["default"](innerTx.fee).minus(resourceFee).div(innerOps);
       var base = new _bignumber["default"](baseFee);
 
       // The fee rate for fee bump is at least the fee rate of the inner transaction

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stellar/stellar-base",
-  "version": "14.0.4",
+  "version": "14.1.0",
   "description": "Low-level support library for the Stellar network.",
   "main": "./lib/index.js",
   "browser": {