feat: replace .native property with .as_uint64() and .as_biguint() methods in arc4.Uint

Author: boblat

examples/arc4-simple-voting/contract.algo.spec.ts

@@ -40,6 +40,6 @@ describe('Voting contract', () => {
 
     contract.votes.value = Uint64(5)
     const votes = contract.getVotes()
-    expect(votes.native).toEqual(5)
+    expect(votes.asUint64()).toEqual(5)
   })
 })

examples/marketplace/contract.algo.spec.ts

@@ -40,7 +40,7 @@ describe('DigitalMarketplace', () => {
       nonce: testNonce,
     })
     const listingValue = interpretAsArc4<ListingValue>(Bytes(ctx.ledger.getBox(contract, Bytes('listings').concat(listingKey.bytes))))
-    expect(listingValue.deposited.native).toEqual(10)
+    expect(listingValue.deposited.asUint64()).toEqual(10)
   })
 
   test('deposit', () => {
@@ -101,7 +101,7 @@ describe('DigitalMarketplace', () => {
 
     // Assert
     const updatedListing = interpretAsArc4<ListingValue>(Bytes(ctx.ledger.getBox(contract, Bytes('listings').concat(listingKey.bytes))))
-    expect(updatedListing.unitaryPrice.native).toEqual(testUnitaryPrice.native)
+    expect(updatedListing.unitaryPrice.asUint64()).toEqual(testUnitaryPrice.asUint64())
   })
 
   test('buy', () => {
@@ -130,14 +130,14 @@ describe('DigitalMarketplace', () => {
       testNonce,
       ctx.any.txn.payment({
         receiver: ctx.defaultSender,
-        amount: contract.quantityPrice(testBuyQuantity.native, testUnitaryPrice.native, testAsset.decimals),
+        amount: contract.quantityPrice(testBuyQuantity.asUint64(), testUnitaryPrice.asUint64(), testAsset.decimals),
       }),
-      testBuyQuantity.native,
+      testBuyQuantity.asUint64(),
     )
 
     // Assert
     const updatedListing = interpretAsArc4<ListingValue>(Bytes(ctx.ledger.getBox(contract, Bytes('listings').concat(listingKey.bytes))))
-    expect(updatedListing.deposited.native).toEqual(initialDeposit.native - testBuyQuantity.native)
+    expect(updatedListing.deposited.asUint64()).toEqual(initialDeposit.asUint64() - testBuyQuantity.asUint64())
     expect(ctx.txn.lastGroup.getItxnGroup(0).getAssetTransferInnerTxn(0).assetReceiver).toEqual(ctx.defaultSender)
   })
 
@@ -176,7 +176,7 @@ describe('DigitalMarketplace', () => {
     const assetTransferTxn = ctx.txn.lastGroup.getItxnGroup(1).getAssetTransferInnerTxn(0)
     expect(assetTransferTxn.xferAsset).toEqual(testAsset)
     expect(assetTransferTxn.assetReceiver).toEqual(testOwner.native)
-    expect(assetTransferTxn.assetAmount).toEqual(initialDeposit.native)
+    expect(assetTransferTxn.assetAmount).toEqual(initialDeposit.asUint64())
   })
 
   test('bid', () => {
@@ -200,9 +200,9 @@ describe('DigitalMarketplace', () => {
     })
 
     const bidder = ctx.any.account()
-    const bidQuantity = ctx.any.arc4.uint64(0, BigInt(initialDeposit.native))
-    const bidPrice = ctx.any.arc4.uint64(initialPrice.native + 1, 10000000n)
-    const bidAmount = contract.quantityPrice(bidQuantity.native, bidPrice.native, testAsset.decimals)
+    const bidQuantity = ctx.any.arc4.uint64(0, BigInt(initialDeposit.asUint64()))
+    const bidPrice = ctx.any.arc4.uint64(initialPrice.asUint64() + 1, 10000000n)
+    const bidAmount = contract.quantityPrice(bidQuantity.asUint64(), bidPrice.asUint64(), testAsset.decimals)
 
     // Act
     ctx.txn.createScope([ctx.any.txn.applicationCall({ appId: app, sender: bidder })]).execute(() => {
@@ -223,8 +223,8 @@ describe('DigitalMarketplace', () => {
     // Assert
     const updatedListing = contract.listings(listingKey).value
     expect(updatedListing.bidder.native).toEqual(bidder)
-    expect(updatedListing.bid.native).toEqual(bidQuantity.native)
-    expect(updatedListing.bidUnitaryPrice.native).toEqual(bidPrice.native)
+    expect(updatedListing.bid.asUint64()).toEqual(bidQuantity.asUint64())
+    expect(updatedListing.bidUnitaryPrice.asUint64()).toEqual(bidPrice.asUint64())
   })
 
   test('acceptBid', () => {
@@ -234,7 +234,7 @@ describe('DigitalMarketplace', () => {
     // Arrange
     const owner = ctx.defaultSender
     const initialDeposit = ctx.any.arc4.uint64(1, 10000000n)
-    const bidQuantity = ctx.any.arc4.uint64(0, BigInt(initialDeposit.native))
+    const bidQuantity = ctx.any.arc4.uint64(0, BigInt(initialDeposit.asUint64()))
     const bidPrice = ctx.any.arc4.uint64(0, 10000000n)
     const bidder = ctx.any.account()
 
@@ -251,15 +251,15 @@ describe('DigitalMarketplace', () => {
       bidUnitaryPrice: bidPrice,
     })
 
-    const minQuantity = initialDeposit.native < bidQuantity.native ? initialDeposit.native : bidQuantity.native
-    const expectedPayment = contract.quantityPrice(minQuantity, bidPrice.native, testAsset.decimals)
+    const minQuantity = initialDeposit.asUint64() < bidQuantity.asUint64() ? initialDeposit.asUint64() : bidQuantity.asUint64()
+    const expectedPayment = contract.quantityPrice(minQuantity, bidPrice.asUint64(), testAsset.decimals)
 
     // Act
     contract.acceptBid(testAsset, testNonce)
 
     // Assert
     const updatedListing = contract.listings(listingKey).value
-    expect(updatedListing.deposited.native).toEqual(initialDeposit.native - minQuantity)
+    expect(updatedListing.deposited.asUint64()).toEqual(initialDeposit.asUint64() - minQuantity)
 
     expect(ctx.txn.lastGroup.itxnGroups.length).toEqual(2)
 

examples/marketplace/contract.algo.ts

@@ -117,7 +117,7 @@ export default class DigitalMarketplace extends arc4.Contract {
       bidUnitaryPrice: existing.bidUnitaryPrice,
       bidder: existing.bidder,
       unitaryPrice: existing.unitaryPrice,
-      deposited: new arc4.Uint64(existing.deposited.native + xfer.assetAmount),
+      deposited: new arc4.Uint64(existing.deposited.asUint64() + xfer.assetAmount),
     })
   }
 
@@ -149,7 +149,7 @@ export default class DigitalMarketplace extends arc4.Contract {
 
     const listing = clone(this.listings(key).value)
 
-    const amountToBePaid = this.quantityPrice(quantity, listing.unitaryPrice.native, asset.decimals)
+    const amountToBePaid = this.quantityPrice(quantity, listing.unitaryPrice.asUint64(), asset.decimals)
 
     assert(buyPay.sender === Txn.sender)
     assert(buyPay.receiver.bytes === owner.bytes)
@@ -160,7 +160,7 @@ export default class DigitalMarketplace extends arc4.Contract {
       bidUnitaryPrice: listing.bidUnitaryPrice,
       bidder: listing.bidder,
       unitaryPrice: listing.unitaryPrice,
-      deposited: new arc4.Uint64(listing.deposited.native - quantity),
+      deposited: new arc4.Uint64(listing.deposited.asUint64() - quantity),
     })
 
     itxn
@@ -182,7 +182,7 @@ export default class DigitalMarketplace extends arc4.Contract {
 
     const listing = clone(this.listings(key).value)
     if (listing.bidder !== new arc4.Address()) {
-      const currentBidDeposit = this.quantityPrice(listing.bid.native, listing.bidUnitaryPrice.native, asset.decimals)
+      const currentBidDeposit = this.quantityPrice(listing.bid.asUint64(), listing.bidUnitaryPrice.asUint64(), asset.decimals)
       itxn.payment({ receiver: listing.bidder.native, amount: currentBidDeposit }).submit()
     }
 
@@ -194,7 +194,7 @@ export default class DigitalMarketplace extends arc4.Contract {
       .assetTransfer({
         xferAsset: asset,
         assetReceiver: Txn.sender,
-        assetAmount: listing.deposited.native,
+        assetAmount: listing.deposited.asUint64(),
       })
       .submit()
   }
@@ -205,14 +205,14 @@ export default class DigitalMarketplace extends arc4.Contract {
 
     const listing = clone(this.listings(key).value)
     if (listing.bidder !== new arc4.Address()) {
-      assert(unitaryPrice.native > listing.bidUnitaryPrice.native)
+      assert(unitaryPrice.asUint64() > listing.bidUnitaryPrice.asUint64())
 
-      const currentBidAmount = this.quantityPrice(listing.bid.native, listing.bidUnitaryPrice.native, asset.decimals)
+      const currentBidAmount = this.quantityPrice(listing.bid.asUint64(), listing.bidUnitaryPrice.asUint64(), asset.decimals)
 
       itxn.payment({ receiver: listing.bidder.native, amount: currentBidAmount }).submit()
     }
 
-    const amountToBeBid = this.quantityPrice(quantity.native, unitaryPrice.native, asset.decimals)
+    const amountToBeBid = this.quantityPrice(quantity.asUint64(), unitaryPrice.asUint64(), asset.decimals)
 
     assert(bidPay.sender === Txn.sender)
     assert(bidPay.receiver === Global.currentApplicationAddress)
@@ -234,9 +234,9 @@ export default class DigitalMarketplace extends arc4.Contract {
     const listing = clone(this.listings(key).value)
     assert(listing.bidder !== new arc4.Address())
 
-    const minQuantity = listing.deposited.native < listing.bid.native ? listing.deposited.native : listing.bid.native
+    const minQuantity = listing.deposited.asUint64() < listing.bid.asUint64() ? listing.deposited.asUint64() : listing.bid.asUint64()
 
-    const bestBidAmount = this.quantityPrice(minQuantity, listing.bidUnitaryPrice.native, asset.decimals)
+    const bestBidAmount = this.quantityPrice(minQuantity, listing.bidUnitaryPrice.asUint64(), asset.decimals)
 
     itxn.payment({ receiver: Txn.sender, amount: bestBidAmount }).submit()
 
@@ -252,8 +252,8 @@ export default class DigitalMarketplace extends arc4.Contract {
       bidder: listing.bidder,
       bidUnitaryPrice: listing.bidUnitaryPrice,
       unitaryPrice: listing.unitaryPrice,
-      deposited: new arc4.Uint64(listing.deposited.native - minQuantity),
-      bid: new arc4.Uint64(listing.bid.native - minQuantity),
+      deposited: new arc4.Uint64(listing.deposited.asUint64() - minQuantity),
+      bid: new arc4.Uint64(listing.bid.asUint64() - minQuantity),
     })
   }
 }

examples/voting/contract.algo.ts

@@ -131,9 +131,9 @@ export class VotingRoundApp extends arc4.Contract {
       if (questionIndex > 0) {
         note += ','
       }
-      if (questionOptions.native > 0) {
+      if (questionOptions.asUint64() > 0) {
         note += '['
-        for (let optionIndex = Uint64(0); optionIndex <= questionOptions.native; optionIndex++) {
+        for (let optionIndex = Uint64(0); optionIndex <= questionOptions.asUint64(); optionIndex++) {
           if (optionIndex > 0) {
             note += ','
           }
@@ -204,8 +204,8 @@ export class VotingRoundApp extends arc4.Contract {
     )
     let cumulativeOffset = Uint64(0)
     for (const questionIndex of urange(questionsCount)) {
-      const answerOptionIndex = answerIds.at(questionIndex).native
-      const optionsCount = this.optionCounts.value.at(questionIndex).native
+      const answerOptionIndex = answerIds.at(questionIndex).asUint64()
+      const optionsCount = this.optionCounts.value.at(questionIndex).asUint64()
       assert(answerOptionIndex < optionsCount, 'Answer option index invalid')
       this.incrementVoteInBox(cumulativeOffset + answerOptionIndex)
       cumulativeOffset += optionsCount
@@ -228,7 +228,7 @@ export class VotingRoundApp extends arc4.Contract {
 
     let totalOptions = Uint64(0)
     for (const item of optionCounts) {
-      totalOptions += item.native
+      totalOptions += item.asUint64()
     }
     this.optionCounts.value = clone(optionCounts)
     this.totalOptions.value = totalOptions

src/impl/encoded-types/encoded-types.ts

@@ -18,7 +18,13 @@ import {
 } from '@algorandfoundation/algorand-typescript/arc4'
 import { encodingUtil } from '@algorandfoundation/puya-ts'
 import assert from 'assert'
-import { ABI_RETURN_VALUE_LOG_PREFIX, ALGORAND_ADDRESS_BYTE_LENGTH, ALGORAND_CHECKSUM_BYTE_LENGTH, UINT64_SIZE } from '../../constants'
+import {
+  ABI_RETURN_VALUE_LOG_PREFIX,
+  ALGORAND_ADDRESS_BYTE_LENGTH,
+  ALGORAND_CHECKSUM_BYTE_LENGTH,
+  MAX_UINT64,
+  UINT64_SIZE,
+} from '../../constants'
 import { AvmError, avmInvariant, CodeError, InternalError } from '../../errors'
 import { nameOfType, type DeliberateAny } from '../../typescript-helpers'
 import {
@@ -99,7 +105,20 @@ export class Uint<N extends BitSize> extends _Uint<N> {
 
   get native() {
     const bigIntValue = encodingUtil.uint8ArrayToBigInt(this.value)
-    return (this.bitSize <= UINT64_SIZE ? asUint64(bigIntValue) : asBigUint(bigIntValue)) as _Uint<N>['native']
+    return this.bitSize <= UINT64_SIZE ? asUint64(bigIntValue) : asBigUint(bigIntValue)
+  }
+
+  asUint64() {
+    const bigIntValue = encodingUtil.uint8ArrayToBigInt(this.value)
+    if (bigIntValue > MAX_UINT64) {
+      throw new CodeError('value too large to fit in uint64')
+    }
+    return asUint64(bigIntValue)
+  }
+
+  asBigUint() {
+    const bigIntValue = encodingUtil.uint8ArrayToBigInt(this.value)
+    return asBigUint(bigIntValue)
   }
 
   get bytes(): bytes {
@@ -155,7 +174,7 @@ export class UFixed<N extends BitSize, M extends number> extends _UFixed<N, M> {
 
   get native() {
     const bigIntValue = encodingUtil.uint8ArrayToBigInt(this.value)
-    return (this.bitSize <= UINT64_SIZE ? asUint64(bigIntValue) : asBigUint(bigIntValue)) as _UFixed<N, M>['native']
+    return this.bitSize <= UINT64_SIZE ? asUint64(bigIntValue) : asBigUint(bigIntValue)
   }
 
   get bytes(): bytes {
@@ -201,8 +220,12 @@ export class Byte extends _Byte {
     this.value = new Uint<8>(typeInfo, v)
   }
 
-  get native() {
-    return this.value.native
+  asUint64() {
+    return this.value.asUint64()
+  }
+
+  asBigUint() {
+    return this.value.asBigUint()
   }
 
   get bytes(): bytes {

src/set-up.ts

@@ -33,6 +33,15 @@ function doAddEqualityTesters(expectObj: ExpectObj) {
       // Defer to other testers
       return undefined
     },
+    function NumericLiteralIsNumericPrimitive(this: TesterContext, subject, test, customTesters): boolean | undefined {
+      if (typeof subject === 'bigint' || typeof subject === 'number') {
+        const testValue = test instanceof Uint64Cls || test instanceof BigUintCls ? test.valueOf() : undefined
+        if (testValue !== undefined) return this.equals(BigInt(subject), testValue, customTesters)
+        return undefined
+      }
+      // Defer to other testers
+      return undefined
+    },
     function BytesPrimitiveIsUint8Array(this: TesterContext, subject, test, customTesters): boolean | undefined {
       if (subject instanceof BytesCls) {
         const testValue = test instanceof Uint8Array ? test : undefined

tests/arc4/address.algo.spec.ts

@@ -44,7 +44,7 @@ describe('arc4.Address', () => {
     const result = new Address(value)
     let i = 0
     for (const entry of result) {
-      expect(entry.native).toEqual(uint8ArrayValue[i++])
+      expect(entry.asUint64()).toEqual(uint8ArrayValue[i++])
     }
     expect(result.length).toEqual(uint8ArrayValue.length)
   })
@@ -54,7 +54,7 @@ describe('arc4.Address', () => {
     const result = new Address(stringValue)
     let i = 0
     for (const entry of result) {
-      expect(entry.native).toEqual(uint8ArrayValue[i++])
+      expect(entry.asUint64()).toEqual(uint8ArrayValue[i++])
     }
     expect(result.length).toEqual(uint8ArrayValue.length)
   })
@@ -64,7 +64,7 @@ describe('arc4.Address', () => {
     const result = new Address(accountValue)
     let i = 0
     for (const entry of result) {
-      expect(entry.native).toEqual(uint8ArrayValue[i++])
+      expect(entry.asUint64()).toEqual(uint8ArrayValue[i++])
     }
     expect(result.length).toEqual(uint8ArrayValue.length)
   })

tests/arc4/byte.algo.spec.ts

@@ -44,7 +44,7 @@ describe('arc4.Byte', async () => {
 
     const result = new Byte(value)
 
-    expect(result.native).toEqual(expected)
+    expect(result.asUint64()).toEqual(expected)
     expect(avmResult).toEqual(expected)
   })
 
@@ -85,13 +85,13 @@ describe('arc4.Byte', async () => {
           case '!==':
             return a !== b
           case '<':
-            return a.native < b.native
+            return a.asUint64() < b.asUint64()
           case '<=':
-            return a.native <= b.native
+            return a.asUint64() <= b.asUint64()
           case '>':
-            return a.native > b.native
+            return a.asUint64() > b.asUint64()
           case '>=':
-            return a.native >= b.native
+            return a.asUint64() >= b.asUint64()
           default:
             throw new Error(`Unknown operator: ${op}`)
         }
@@ -118,7 +118,7 @@ describe('arc4.Byte', async () => {
     const avmResult = await getAvmResult({ appClient }, 'verify_byte_from_bytes', value)
     const result = interpretAsArc4<Byte>(Bytes(value))
 
-    expect(result.native).toEqual(avmResult)
+    expect(result.asUint64()).toEqual(avmResult)
   })
 
   test.for([encodingUtil.bigIntToUint8Array(0n, 2), encodingUtil.bigIntToUint8Array(255n, 8)])(
@@ -127,7 +127,7 @@ describe('arc4.Byte', async () => {
       await expect(getAvmResult({ appClient }, 'verify_byte_from_bytes', value)).rejects.toThrowError(invalidBytesLengthError)
 
       const result = interpretAsArc4<Byte>(Bytes(value))
-      expect(result.native).toEqual(encodingUtil.uint8ArrayToBigInt(value))
+      expect(result.asUint64()).toEqual(encodingUtil.uint8ArrayToBigInt(value))
     },
   )
 
@@ -141,7 +141,7 @@ describe('arc4.Byte', async () => {
 
     const result = interpretAsArc4<Byte>(Bytes(logValue), 'log')
     expect(avmResult).toEqual(expected)
-    expect(result.native).toEqual(expected)
+    expect(result.asUint64()).toEqual(expected)
   })
 
   test.for([
@@ -169,7 +169,7 @@ describe('arc4.Byte', async () => {
       await expect(() => getAvmResult({ appClient }, 'verify_byte_from_log', logValue)).rejects.toThrowError(invalidBytesLengthError)
 
       const result = interpretAsArc4<Byte>(Bytes(logValue), 'log')
-      expect(result.native).toEqual(encodingUtil.uint8ArrayToBigInt(value))
+      expect(result.asUint64()).toEqual(encodingUtil.uint8ArrayToBigInt(value))
     },
   )
 })